assimp: ASSIMP - Open Asset Import Library

  • Main Page
  • Related Pages
  • Namespaces
  • Classes
  • Files

ASSIMP - Open Asset Import Library

r400

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 yet been implemented, and some formats have not completely been documented by their inventors):

Collada ( *.dae;*.xml ) 3
Biovision BVH ( *.bvh )
3D Studio Max 3DS ( *.3ds )
3D Studio Max ASE ( *.ase )
Wavefront Object ( *.obj )
Stanford Polygon Library ( *.ply )
AutoCAD DXF ( *.dxf ) 2
Neutral File Format ( *.nff )
Sense8 WorldToolkit ( *.nff )
LightWave Model ( *.lwo )
MODO model ( *.lxo )
Valve Model ( *.smd,*.vta ) 3
Quake I ( *.mdl )
Quake II ( *.md2 )
Quake III ( *.md3 )
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 )

 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.

The Viewer

The ASSIMP viewer is a standalone Windows/DirectX application that was developed along with the library. It is very useful for quickly examining the contents of a scene file and test the suitability of its contents for realtime rendering. The viewer offers a lot of additional features to view, interact with or export bits of the data. See the Viewer page for a detailed description of its capabilities.

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 Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: Installation

  • Classes
  • Files

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.hpp> or <assimp.h> plus some others starting with <aiTypes.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 section on MSVC and the STL

Microsoft Compilers & STL

In VC8 and VC9 Microsoft has introduced some STL debugging features. A good example are improved iterator checks and various useful debug checks. Actually they are really helpful for debugging, but they're extremely slow. They're so extremely slow that they can make the STL up to 100 times slower (imagine a std::vector<T>::operator[] performing 3 or 4 single checks! scary ...).

These security enhancements are - thanks MS! - also active in release builds, rendering ASSIMP several times slower. However, it is possible to disable them by defining

_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: It's ok. There's no STL used in the DLL 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 section describing 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 (dummy) implementations of the various boost utility classes used. However, you'll loose functionality (e.g. threading) by doing this. So, if it is possible to use boost, you should use boost. See the NoBoost for more details.

Once boost is working, you have to set up a project for the ASSIMP library in your favourite 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
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 next section for more details.

Single-threaded build

-- currently there is no difference between single-thread and normal builds --

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. Don't forget to copy the DLL to the directory of your executable :-)

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 dir. However, if you happen to encounter *very* strange problems try changing the runtime to multithreaded (Debug) DLL.

Building against STLport

If your compiler's default implementation of the STL is too slow, lacks some features, contains bugs or if you just want to tweak ASSIMP's performance a little try a build against STLport. STLport is a free, fast and secure STL replacement that works with all major compilers and platforms. To get it visit their website at <stlport.org> and download the latest STLport release. Usually you'll just need to run 'configure' + a makefile (see the README for more details). Don't miss to add <stlport_root>/stlport to your compiler's default include paths - prior to the directory where the compiler vendor's STL lies. Do the same for <stlport_root>/lib and recompile ASSIMP. To ensure you're really building against STLport see aiGetCompileFlags().
Usually building ASSIMP against STLport yields a better overall performance so it might be worth a try if the library is too slow for you.
Generated on Sun Jul 19 17:01:49 2009 for assimp by doxygen 1.5.8


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.hpp>      // C++ importer interface
#include <aiScene.h>       // Output data structure
#include <aiPostProcess.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 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.h>        // Plain-C interface
#include <aiScene.h>       // Output data structure
#include <aiPostProcess.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 <IOStream.h>
#include <IOSystem.h>

// 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 aiFileIO.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 last parameter to aiImportFileEx

Thread-safety and internal multi-threading

The ASSIMP library can be accessed by multiple threads simultaneously, as long as the following prerequisites are fulfilled:
  • When using the C++-API make sure you create a new Importer instance for each thread. Constructing instances of Importer is expensive, so it might be a good idea to let every thread maintain its own thread-local instance (use it to load as many models as you want).
  • The C-API is threadsafe as long as AI_C_THREADSAFE is defined. That's the default.
  • When supplying custom IO logic, make sure your underyling implementation is thead-safe.
  • Custom log streams or logger replacements have to be thread-safe, too.

See the Single-threaded build section to learn how to build a lightweight variant of ASSIMP which is not thread-safe and does not utilize multiple threads for loading.

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, +Y points away from the viewer into the screen and +Z points upwards. Several modeling packages such as 3D Studio Max use this coordinate system as well. 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.

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. Depending on the file format and the modelling package the node hierarchy of the skeleton is either a child of the mesh node or a sibling of the mesh node. Therefore b3) stops at both the mesh's node and the mesh's node's parent. 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 aiMaterial.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
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 is matching 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);

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.

INCOMPLETE! WIP!

// ---------------------------------------------------------------------------------------
// 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);

  if (blend_func == multiply)
       return prev
}


assimp: The Viewer

The Viewer

Sinn: StandAlone-Test für die Importlib Benutzung: was kann er und wie löst man es aus Build: alles von CustomBuild + DirectX + MFC?


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
aiBone | A single bone of a mesh
aiCamera | Helper structure to describe a virtual camera
aiColor3D | Represents a color in Red-Green-Blue space
aiColor4D | Represents a color in Red-Green-Blue space including an alpha component
aiFace | A single face in a mesh, referring to multiple vertices
aiFile | Represents a read/write file
aiFileIO | Defines Assimp's way of accessing files
aiLight | Helper structure to describe a light source
aiLogStream | Represents a log stream
aiMaterial | Data structure for a material
aiMatrix3x3 | Represents a row-major 3x3 matrix
aiMatrix4x4 | Represents a row-major 4x4 matrix, use this for homogeneous coordinates
aiMesh | A mesh represents a geometry or model with a single material
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
aiQuaternion | 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 a 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
aiVector2D | Represents a two-dimensional vector
aiVector3D | 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::DefaultLogger | Primary logging implementation of Assimp
Assimp::Importer | Forms an C++ interface to the functionality of the Open Asset Import Library
Assimp::Intern::AllocateFromAssimpHeap | Internal helper class to utilize our internal new/delete routines for allocating object of this and derived classes
Assimp::Interpolator< T > | Utility class to simplify interpolations of various data types
Assimp::IOStream | Class to handle file I/O for C++
Assimp::IOSystem | Interface to the file system
Assimp::Logger | Abstract interface for logger implementations
Assimp::LogStream | Abstract interface for log stream implementations
Assimp::NullLogger | Empty logging implementation


assimp: aiAnimation Struct Reference

  • Class Index
  • Class Hierarchy
  • Class Members

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.
aiString mName
The name of the animation.
unsigned int | mNumChannels
The number of bone 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.

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.

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:
  • aiAnim.h


assimp: aiBone Struct Reference

aiBone Struct Reference

A single bone of a mesh. More...

List of all members.

Public Member Functions

aiBone (const aiBone &other)
Copy constructor.
aiBone ()
Default 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.
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.

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:
  • aiMesh.h


assimp: aiCamera Struct Reference

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 farer 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:
  • aiCamera.h


assimp: aiColor3D Struct Reference

aiColor3D Struct Reference

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

List of all members.

Public Member Functions

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

Multiply with a scalar.

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

Component-wise multiplication.

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 ) [inline]

Access a specific color component.

float aiColor3D::operator[] ( unsigned int i ) const [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:
  • aiTypes.h


assimp: aiColor4D Struct Reference

aiColor4D Struct Reference

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

List of all members.

Public Member Functions

aiColor4D (const aiColor4D &o)
aiColor4D (float _r, float _g, float _b, float _a)
aiColor4D ()
bool | IsBlack () const
Check whether a color is black.
bool | operator!= (const aiColor4D &other) const
Component-wise inverse comparison.
bool | operator== (const aiColor4D &other) const
Component-wise comparison.
float & | operator[] (unsigned int i)
Access a specific color component.
float | operator[] (unsigned int i) const
Access a specific color component.

Public Attributes

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

Detailed Description

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

Constructor & Destructor Documentation

aiColor4D::aiColor4D ( ) [inline]

aiColor4D::aiColor4D | ( | float | _r,
 |  | float | _g,
 |  | float | _b,
 |  | float | _a |
 | ) |  |  | [inline]

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

Member Function Documentation

bool aiColor4D::IsBlack ( ) const [inline]

Check whether a color is black.

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

Component-wise inverse comparison.

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

Component-wise comparison.

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

Access a specific color component.

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

Access a specific color component.

Member Data Documentation

float aiColor4D::a

float aiColor4D::b

float aiColor4D::g

float aiColor4D::r

Red, green, blue and alpha color values.

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


assimp: aiFace Struct Reference

aiFace Struct Reference

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

List of all members.

Public Member Functions

aiFace (const aiFace &o)
Copy constructor. Copy the index array.
aiFace ()
Default constructor.
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. 3 for a triangle, >3 for polygon.

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. 3 for a triangle, >3 for polygon.

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


assimp: aiFile Struct Reference

aiFile Struct Reference

Represents a read/write file. 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

Represents a read/write file.

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.

See also:
aiImportFileEx

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:
  • aiFileIO.h


assimp: aiFileIO Struct Reference

aiFileIO Struct Reference

Defines Assimp's way of accessing files. 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

Defines Assimp's way of accessing files.

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 this 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:
  • aiFileIO.h


assimp: aiLight Struct Reference

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:
  • aiLight.h


assimp: aiLogStream Struct Reference

aiLogStream Struct Reference

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

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:
  • assimp.h


assimp: aiMaterial Struct Reference

aiMaterial Struct Reference

Data structure for a material. More...

List of all members.

Public Member Functions

aiMaterial ()
NOTE: no initialization, instance Assimp::MaterialHelper instead.
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 a texture from a material.
~aiMaterial ()

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 ( ) [inline]

NOTE: no initialization, instance Assimp::MaterialHelper instead.

aiMaterial::~aiMaterial ( )

Member Function Documentation

template<typename Type >
aiReturn aiMaterial::Get | ( | const char * | pKey,
 |  | unsigned int | type,
 |  | unsigned int | idx,
 |  | Type & | pOut |
 | ) |  |  | const [inline]

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

template<typename Type >
aiReturn aiMaterial::Get | ( | const char * | pKey,
 |  | unsigned int | type,
 |  | unsigned int | idx,
 |  | Type * | pOut,
 |  | unsigned int * | pMax |
 | ) |  |  | const [inline]

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.

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

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:
  • aiMaterial.h


assimp: aiMatrix3x3 Struct Reference

aiMatrix3x3 Struct Reference

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

List of all members.

Public Member Functions

aiMatrix3x3 (const aiMatrix4x4 &pMatrix)
Construction from a 4x4 matrix.
aiMatrix3x3 (float _a1, float _a2, float _a3, float _b1, float _b2, float _b3, float _c1, float _c2, float _c3)
aiMatrix3x3 ()
float | Determinant () const
aiMatrix3x3 & Inverse ()
Invert the matrix.
bool | operator!= (const aiMatrix4x4 m) const
aiMatrix3x3 | operator* (const aiMatrix3x3 &m) const
aiMatrix3x3 & | operator*= (const aiMatrix3x3 &m)
bool | operator== (const aiMatrix4x4 m) const
const float * | operator[] (unsigned int p_iIndex) const
float * | operator[] (unsigned int p_iIndex)
aiMatrix3x3 & Transpose ()
Transpose the matrix.

Static Public Member Functions

static aiMatrix3x3 & | FromToMatrix (const aiVector3D &from, const aiVector3D &to, aiMatrix3x3 &out)
A function for creating a rotation matrix that rotates a vector called "from" into another vector called "to".
static aiMatrix3x3 & | Rotation (float a, const aiVector3D &axis, aiMatrix3x3 &out)
Returns a rotation matrix for a rotation around an arbitrary axis.
static aiMatrix3x3 & | RotationZ (float a, aiMatrix3x3 &out)
Returns a rotation matrix for a rotation around z.
static aiMatrix3x3 & | Translation (const aiVector2D &v, aiMatrix3x3 &out)
Returns a translation matrix.

Public Attributes

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

Detailed Description

Represents a row-major 3x3 matrix.

There's much confusion about matrix layouts (colum vs. row order). This is *always* a row-major matrix. Even with the aiProcess_ConvertToLeftHanded flag.

Constructor & Destructor Documentation

aiMatrix3x3::aiMatrix3x3 ( ) [inline]

aiMatrix3x3::aiMatrix3x3 | ( | float | _a1,
 |  | float | _a2,
 |  | float | _a3,
 |  | float | _b1,
 |  | float | _b2,
 |  | float | _b3,
 |  | float | _c1,
 |  | float | _c2,
 |  | float | _c3 |
 | ) |  |  | [inline]

aiMatrix3x3::aiMatrix3x3 ( const aiMatrix4x4 & pMatrix ) [inline, explicit]

Construction from a 4x4 matrix.

The remaining parts of the matrix are ignored.

Member Function Documentation

float aiMatrix3x3::Determinant ( ) const [inline]

aiMatrix3x3 & aiMatrix3x3::FromToMatrix | ( | const aiVector3D & | from,
 |  | const aiVector3D & | to,
 |  | aiMatrix3x3 & | mtx |
 | ) |  |  | [inline, static]

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

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

aiMatrix3x3 & aiMatrix3x3::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 float f is qnan.

bool aiMatrix3x3::operator!= ( const aiMatrix4x4 m ) const [inline]

aiMatrix3x3 aiMatrix3x3::operator* ( const aiMatrix3x3 & m ) const [inline]

aiMatrix3x3 & aiMatrix3x3::operator*= ( const aiMatrix3x3 & m ) [inline]

bool aiMatrix3x3::operator== ( const aiMatrix4x4 m ) const [inline]

const float * aiMatrix3x3::operator[] ( unsigned int p_iIndex ) const [inline]

float * aiMatrix3x3::operator[] ( unsigned int p_iIndex ) [inline]

aiMatrix3x3 & aiMatrix3x3::Rotation | ( | float | a,
 |  | const aiVector3D & | axis,
 |  | aiMatrix3x3 & | 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

aiMatrix3x3 & aiMatrix3x3::RotationZ | ( | float | a,
 |  | aiMatrix3x3 & | 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

aiMatrix3x3 & aiMatrix3x3::Translation | ( | const aiVector2D & | v,
 |  | aiMatrix3x3 & | out |
 | ) |  |  | [inline, static]

Returns a translation matrix.

Parameters:
v | Translation vector
out | Receives the output matrix
Returns:
Reference to the output matrix

aiMatrix3x3 & aiMatrix3x3::Transpose ( ) [inline]

Transpose the matrix.

Member Data Documentation

float aiMatrix3x3::a1

float aiMatrix3x3::a2

float aiMatrix3x3::a3

float aiMatrix3x3::b1

float aiMatrix3x3::b2

float aiMatrix3x3::b3

float aiMatrix3x3::c1

float aiMatrix3x3::c2

float aiMatrix3x3::c3

The documentation for this struct was generated from the following files:
  • aiMatrix3x3.h
  • aiMatrix3x3.inl


assimp: aiMatrix4x4 Struct Reference

aiMatrix4x4 Struct Reference

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

List of all members.

Public Member Functions

aiMatrix4x4 (const aiMatrix3x3 &m)
Constructor from 3x3 matrix.
aiMatrix4x4 (float _a1, float _a2, float _a3, float _a4, float _b1, float _b2, float _b3, float _b4, float _c1, float _c2, float _c3, float _c4, float _d1, float _d2, float _d3, float _d4)
aiMatrix4x4 ()
void | Decompose (aiVector3D &scaling, aiQuaternion &rotation, aiVector3D &position) const
Decompose a trafo matrix into its original components.
void | DecomposeNoScaling (aiQuaternion &rotation, aiVector3D &position) const
Decompose a trafo matrix with no scaling into its original components.
float | Determinant () const
void | FromEulerAnglesXYZ (const aiVector3D &blubb)
void | FromEulerAnglesXYZ (float x, float y, float z)
Creates a trafo matrix from a set of euler angles.
aiMatrix4x4 & Inverse ()
Invert the matrix.
bool | IsIdentity () const
Returns true of the matrix is the identity matrix.
bool | operator!= (const aiMatrix4x4 m) const
aiMatrix4x4 | operator* (const aiMatrix4x4 &m) const
aiMatrix4x4 & | operator*= (const aiMatrix4x4 &m)
bool | operator== (const aiMatrix4x4 m) const
const float * | operator[] (unsigned int p_iIndex) const
float * | operator[] (unsigned int p_iIndex)
aiMatrix4x4 & Transpose ()
Transpose the matrix.

Static Public Member Functions

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

Public Attributes

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

Detailed Description

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

There's much confusion about matrix layouts (colum vs. row order). This is *always* a row-major matrix. Even with the aiProcess_ConvertToLeftHanded flag.

Constructor & Destructor Documentation

aiMatrix4x4::aiMatrix4x4 ( ) [inline]

aiMatrix4x4::aiMatrix4x4 | ( | float | _a1,
 |  | float | _a2,
 |  | float | _a3,
 |  | float | _a4,
 |  | float | _b1,
 |  | float | _b2,
 |  | float | _b3,
 |  | float | _b4,
 |  | float | _c1,
 |  | float | _c2,
 |  | float | _c3,
 |  | float | _c4,
 |  | float | _d1,
 |  | float | _d2,
 |  | float | _d3,
 |  | float | _d4 |
 | ) |  |  | [inline]

aiMatrix4x4::aiMatrix4x4 ( const aiMatrix3x3 & m ) [inline, explicit]

Constructor from 3x3 matrix.

The remaining elements are set to identity.

Member Function Documentation

void aiMatrix4x4::Decompose | ( | aiVector3D & | scaling,
 |  | aiQuaternion & | rotation,
 |  | aiVector3D & | 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

void aiMatrix4x4::DecomposeNoScaling | ( | aiQuaternion & | rotation,
 |  | aiVector3D & | 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

float aiMatrix4x4::Determinant ( ) const [inline]

void aiMatrix4x4::FromEulerAnglesXYZ ( const aiVector3D & blubb ) [inline]

void aiMatrix4x4::FromEulerAnglesXYZ | ( | float | x,
 |  | float | y,
 |  | float | 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

aiMatrix4x4 & aiMatrix4x4::FromToMatrix | ( | const aiVector3D & | from,
 |  | const aiVector3D & | to,
 |  | aiMatrix4x4 & | mtx |
 | ) |  |  | [inline, static]

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

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

aiMatrix4x4 & aiMatrix4x4::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 float f is qnan.

bool aiMatrix4x4::IsIdentity ( ) const [inline]

Returns true of the matrix is the identity matrix.

The check is performed against a not so small epsilon.

bool aiMatrix4x4::operator!= ( const aiMatrix4x4 m ) const [inline]

aiMatrix4x4 aiMatrix4x4::operator* ( const aiMatrix4x4 & m ) const [inline]

aiMatrix4x4 & aiMatrix4x4::operator*= ( const aiMatrix4x4 & m ) [inline]

bool aiMatrix4x4::operator== ( const aiMatrix4x4 m ) const [inline]

const float * aiMatrix4x4::operator[] ( unsigned int p_iIndex ) const [inline]

float * aiMatrix4x4::operator[] ( unsigned int p_iIndex ) [inline]

aiMatrix4x4 & aiMatrix4x4::Rotation | ( | float | a,
 |  | const aiVector3D & | axis,
 |  | aiMatrix4x4 & | 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

aiMatrix4x4 & aiMatrix4x4::RotationX | ( | float | a,
 |  | aiMatrix4x4 & | 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

aiMatrix4x4 & aiMatrix4x4::RotationY | ( | float | a,
 |  | aiMatrix4x4 & | 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

aiMatrix4x4 & aiMatrix4x4::RotationZ | ( | float | a,
 |  | aiMatrix4x4 & | 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

aiMatrix4x4 & aiMatrix4x4::Scaling | ( | const aiVector3D & | v,
 |  | aiMatrix4x4 & | out |
 | ) |  |  | [inline, static]

Returns a scaling matrix.

Parameters:
v | Scaling vector
out | Receives the output matrix
Returns:
Reference to the output matrix

aiMatrix4x4 & aiMatrix4x4::Translation | ( | const aiVector3D & | v,
 |  | aiMatrix4x4 & | out |
 | ) |  |  | [inline, static]

Returns a translation matrix.

Parameters:
v | Translation vector
out | Receives the output matrix
Returns:
Reference to the output matrix

aiMatrix4x4 & aiMatrix4x4::Transpose ( ) [inline]

Transpose the matrix.

Member Data Documentation

float aiMatrix4x4::a1

float aiMatrix4x4::a2

float aiMatrix4x4::a3

float aiMatrix4x4::a4

float aiMatrix4x4::b1

float aiMatrix4x4::b2

float aiMatrix4x4::b3

float aiMatrix4x4::b4

float aiMatrix4x4::c1

float aiMatrix4x4::c2

float aiMatrix4x4::c3

float aiMatrix4x4::c4

float aiMatrix4x4::d1

float aiMatrix4x4::d2

float aiMatrix4x4::d3

float aiMatrix4x4::d4

The documentation for this struct was generated from the following files:
  • aiMatrix4x4.h
  • aiMatrix4x4.inl


assimp: aiMesh Struct Reference

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

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.
aiVector3D * mNormals
Vertex normals.
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.

If no special scene flags (such as AI_SCENE_FLAGS_ANIM_SKELETON_ONLY) are set this will always return 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

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.

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. Use code like this

 #define IS_QNAN(f) (f != f)
to check whether a field is qnan).
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::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

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

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.

Note:
If the mesh contains tangents, it automatically also contains bitangents (the bitangent is just the cross product of tangent and normal vectors).

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:
  • aiMesh.h


assimp: aiNode Struct Reference

aiNode Struct Reference

A node in the imported hierarchy. More...

List of all members.

Public Member Functions

aiNode (const std::string &name)
Construction from a specific name.
aiNode ()
Constructor.
aiNode * | FindNode (const char *name)
aiNode * | FindNode (const aiString &name)
Searches for a node with a specific name, beginning at this nodes.
~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 char * 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 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.

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 uniquely named. This is a core design requirement of the library.

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:
  • aiScene.h


assimp: aiNodeAnim Struct Reference

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. 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 ( so you should be able to handle 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:
  • aiAnim.h


assimp: aiPlane Struct Reference

aiPlane Struct Reference

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

List of all members.

Public Member Functions

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

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:
  • aiTypes.h


assimp: aiQuaternion Struct Reference

aiQuaternion Struct Reference

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

List of all members.

Public Member Functions

aiQuaternion (aiVector3D normalized)
Construct from a normalized quaternion stored in a vec3.
aiQuaternion (aiVector3D axis, float angle)
Construct from an axis-angle pair.
aiQuaternion (float rotx, float roty, float rotz)
Construct from euler angles.
aiQuaternion (const aiMatrix3x3 &pRotMatrix)
Construct from rotation matrix.
aiQuaternion (float _w, float _x, float _y, float _z)
aiQuaternion ()
aiQuaternion & Conjugate ()
Compute quaternion conjugate.
aiMatrix3x3 | GetMatrix () const
Returns a matrix representation of the quaternion.
aiQuaternion & Normalize ()
Normalize the quaternion.
bool | operator!= (const aiQuaternion &o) const
aiQuaternion | operator* (const aiQuaternion &two) const
Multiply two quaternions.
bool | operator== (const aiQuaternion &o) const
aiVector3D | Rotate (const aiVector3D &in)
Rotate a point by this quaternion.

Static Public Member Functions

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

Public Attributes

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

Detailed Description

Represents a quaternion in a 4D vector.

Constructor & Destructor Documentation

aiQuaternion::aiQuaternion ( ) [inline]

aiQuaternion::aiQuaternion | ( | float | _w,
 |  | float | _x,
 |  | float | _y,
 |  | float | _z |
 | ) |  |  | [inline]

aiQuaternion::aiQuaternion ( const aiMatrix3x3 & pRotMatrix ) [inline]

Construct from rotation matrix.

Result is undefined if the matrix is not orthonormal.

aiQuaternion::aiQuaternion | ( | float | rotx,
 |  | float | roty,
 |  | float | rotz |
 | ) |  |  | [inline]

Construct from euler angles.

aiQuaternion::aiQuaternion | ( | aiVector3D | axis,
 |  | float | angle |
 | ) |  |  | [inline]

Construct from an axis-angle pair.

aiQuaternion::aiQuaternion ( aiVector3D normalized ) [inline]

Construct from a normalized quaternion stored in a vec3.

Member Function Documentation

aiQuaternion & aiQuaternion::Conjugate ( ) [inline]

Compute quaternion conjugate.

aiMatrix3x3 aiQuaternion::GetMatrix ( ) const [inline]

Returns a matrix representation of the quaternion.

void aiQuaternion::Interpolate | ( | aiQuaternion & | pOut,
 |  | const aiQuaternion & | pStart,
 |  | const aiQuaternion & | pEnd,
 |  | float | 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.

aiQuaternion & aiQuaternion::Normalize ( ) [inline]

Normalize the quaternion.

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

aiQuaternion aiQuaternion::operator* ( const aiQuaternion & two ) const [inline]

Multiply two quaternions.

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

aiVector3D aiQuaternion::Rotate ( const aiVector3D & in ) [inline]

Rotate a point by this quaternion.

Member Data Documentation

float aiQuaternion::w

w,x,y,z components of the quaternion

float aiQuaternion::x

float aiQuaternion::y

float aiQuaternion::z

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


assimp: aiQuatKey Struct Reference

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 (double time, const aiQuaternion &value)
Construction from a given time and key value.
aiQuatKey ()
Default constructor.
bool | operator!= (const aiQuatKey &o) const
bool | operator< (const aiQuatKey &o) const
Relational operators.
bool | operator== (const aiQuatKey &o) const
Comparison operators.
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.

For joint animations the rotation is usually expressed using a quaternion.

Member Typedef Documentation

typedef aiQuaternion aiQuatKey::elem_type

Constructor & Destructor Documentation

aiQuatKey::aiQuatKey ( ) [inline]

Default constructor.

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]

Relational operators.

Just the key time is compared For use with std::sort();

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

Comparison operators.

Just the key value is compared For use with std::find();

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:
  • aiAnim.h


assimp: aiRay Struct Reference

aiRay Struct Reference

Represents a ray. More...

List of all members.

Public Member Functions

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

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:
  • aiTypes.h


assimp: aiScene Struct Reference

aiScene Struct Reference

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

List of all members.

Public Member Functions

aiScene ()
Default constructor.
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.
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 ( ) [inline]

Default constructor.

aiScene::~aiScene ( ) [inline]

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.

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. A common example is Quake's MDL format.

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


assimp: aiString Struct Reference

aiString Struct Reference

Represents a string, zero byte terminated. More...

List of all members.

Public Member Functions

aiString (const std::string &pString)
Constructor from std::string.
aiString (const aiString &rOther)
Copy constructor.
aiString ()
Default constructor, the string is set to have zero length.
void | Append (const char *app)
Append a string to the string.
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
Length of the string excluding the terminal 0.

Detailed Description

Represents a string, zero byte terminated.

We use this representation to be C-compatible. The length of such a string is limited to MAXLEN characters (excluding the terminal 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]

Constructor from std::string.

Member Function Documentation

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

Append a string to the string.

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 char * sz ) [inline]

Copy a const char* to the aiString.

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

Copy a std::string to the aiString.

Member Data Documentation

char aiString::data[MAXLEN]

String buffer.

Size limit is MAXLEN

size_t aiString::length

Length of the string excluding the terminal 0.

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


assimp: aiTexel Struct Reference

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:
  • aiTexture.h


assimp: aiTexture Struct Reference

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:
  • aiTexture.h


assimp: aiUVTransform Struct Reference

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:
  • aiMaterial.h


assimp: aiVector2D Struct Reference

aiVector2D Struct Reference

Represents a two-dimensional vector. More...

List of all members.

Public Member Functions

aiVector2D (const aiVector2D &o)
aiVector2D (float _xyz)
aiVector2D (float _x, float _y)
aiVector2D ()
float | Length () const
aiVector2D & Normalize ()
bool | operator!= (const aiVector2D &other) const
const aiVector2D & | operator*= (float f)
const aiVector2D & | operator+= (const aiVector2D &o)
const aiVector2D & | operator-= (const aiVector2D &o)
const aiVector2D & | operator/= (float f)
aiVector2D & | operator= (float f)
bool | operator== (const aiVector2D &other) const
float & | operator[] (unsigned int i)
float | operator[] (unsigned int i) const
void | Set (float pX, float pY)
float | SquareLength () const
const aiVector2D | SymMul (const aiVector2D &o)

Public Attributes

float | x
float | y

Detailed Description

Represents a two-dimensional vector.

Constructor & Destructor Documentation

aiVector2D::aiVector2D ( ) [inline]

aiVector2D::aiVector2D | ( | float | _x,
 |  | float | _y |
 | ) |  |  | [inline]

aiVector2D::aiVector2D ( float _xyz ) [inline]

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

Member Function Documentation

float aiVector2D::Length ( ) const [inline]

aiVector2D& aiVector2D::Normalize ( ) [inline]

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

const aiVector2D& aiVector2D::operator*= ( float f ) [inline]

const aiVector2D& aiVector2D::operator+= ( const aiVector2D & o ) [inline]

const aiVector2D& aiVector2D::operator-= ( const aiVector2D & o ) [inline]

const aiVector2D& aiVector2D::operator/= ( float f ) [inline]

aiVector2D& aiVector2D::operator= ( float f ) [inline]

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

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

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

void aiVector2D::Set | ( | float | pX,
 |  | float | pY |
 | ) |  |  | [inline]

float aiVector2D::SquareLength ( ) const [inline]

const aiVector2D aiVector2D::SymMul ( const aiVector2D & o ) [inline]

Member Data Documentation

float aiVector2D::x

float aiVector2D::y

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


assimp: aiVector3D Struct Reference

aiVector3D Struct Reference

Represents a three-dimensional vector. More...

List of all members.

Public Member Functions

aiVector3D (const aiVector3D &o)
aiVector3D (float _xyz)
aiVector3D (float _x, float _y, float _z)
aiVector3D ()
float | Length () const
Get the length of the vector.
aiVector3D & Normalize ()
Normalize the vector.
bool | operator!= (const aiVector3D &other) const
aiVector3D & | operator*= (const aiMatrix4x4 &mat)
aiVector3D & | operator*= (const aiMatrix3x3 &mat)
const aiVector3D & | operator*= (float f)
const aiVector3D & | operator+= (const aiVector3D &o)
const aiVector3D & | operator-= (const aiVector3D &o)
const aiVector3D & | operator/= (float f)
bool | operator== (const aiVector3D &other) const
float & | operator[] (unsigned int i)
float | operator[] (unsigned int i) const
void | Set (float pX, float pY, float pZ=0.f)
Set the components of a vector.
float | SquareLength () const
Get the squared length of the vector.
const aiVector3D | SymMul (const aiVector3D &o)
Componentwise multiplication of two vectors.

Public Attributes

float | x
float | y
float | z

Detailed Description

Represents a three-dimensional vector.

Constructor & Destructor Documentation

aiVector3D::aiVector3D ( ) [inline]

aiVector3D::aiVector3D | ( | float | _x,
 |  | float | _y,
 |  | float | _z |
 | ) |  |  | [inline]

aiVector3D::aiVector3D ( float _xyz ) [inline]

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

Member Function Documentation

AI_FORCE_INLINE float aiVector3D::Length ( ) const

Get the length of the vector.

Returns:
length

AI_FORCE_INLINE aiVector3D & aiVector3D::Normalize ( )

Normalize the vector.

AI_FORCE_INLINE bool aiVector3D::operator!= ( const aiVector3D & other ) const

AI_FORCE_INLINE aiVector3D & aiVector3D::operator*= ( const aiMatrix4x4 & mat )

AI_FORCE_INLINE aiVector3D & aiVector3D::operator*= ( const aiMatrix3x3 & mat )

AI_FORCE_INLINE const aiVector3D & aiVector3D::operator*= ( float f )

AI_FORCE_INLINE const aiVector3D & aiVector3D::operator+= ( const aiVector3D & o )

AI_FORCE_INLINE const aiVector3D & aiVector3D::operator-= ( const aiVector3D & o )

AI_FORCE_INLINE const aiVector3D & aiVector3D::operator/= ( float f )

AI_FORCE_INLINE bool aiVector3D::operator== ( const aiVector3D & other ) const

AI_FORCE_INLINE float & aiVector3D::operator[] ( unsigned int i )

AI_FORCE_INLINE float aiVector3D::operator[] ( unsigned int i ) const

AI_FORCE_INLINE void aiVector3D::Set | ( | float | pX,
 |  | float | pY,
 |  | float | pZ = 0.f
 | ) |  |

Set the components of a vector.

Parameters:
pX | X component
pY | Y component
pZ | Z component

AI_FORCE_INLINE float aiVector3D::SquareLength ( ) const

Get the squared length of the vector.

Returns:
Square length

AI_FORCE_INLINE const aiVector3D aiVector3D::SymMul ( const aiVector3D & o )

Componentwise multiplication of two vectors.

Note that vec*vec yields the dot product.

Parameters:
o Second factor

Member Data Documentation

float aiVector3D::x

float aiVector3D::y

float aiVector3D::z

The documentation for this struct was generated from the following files:
  • aiVector3D.h
  • aiVector3D.inl


assimp: aiVectorKey Struct Reference

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 (double time, const aiVector3D &value)
Construction from a given time and key value.
aiVectorKey ()
Default constructor.
bool | operator!= (const aiVectorKey &o) const
bool | operator< (const aiVectorKey &o) const
Relational operators.
bool | operator== (const aiVectorKey &o) const
Comparison operators.
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]

Relational operators.

Just the key time is compared For use with std::sort();

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

Comparison operators.

Just the key value is compared For use with std::find();

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:
  • aiAnim.h


assimp: aiVertexWeight Struct Reference

aiVertexWeight Struct Reference

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

List of all members.

Public Member Functions

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

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.

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:
  • aiMesh.h


assimp: Assimp::DefaultLogger Class Reference

Assimp::DefaultLogger

Assimp::DefaultLogger Class Reference

Primary logging implementation 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

Primary logging implementation 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 logstream.

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

Parameters:
pStream | Logstream 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 | Logstream 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 dettached, 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.h


assimp: Assimp::Importer Class Reference

Assimp::Importer

Assimp::Importer Class Reference

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.
BaseImporter * | FindLoader (const char *szExtension)
Find the loader corresponding to a specific file extension.
void | FreeScene ()
Frees the current scene.
const char * | GetErrorString () const
Returns an error description of an error that occurred in ReadFile().
void | GetExtensionList (std::string &szOut)
Get a full list of all file extensions supported by ASSIMP.
void | GetExtensionList (aiString &szOut)
Get a full list of all file extensions supported by ASSIMP.
IOSystem * GetIOHandler ()
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.
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 ()
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 | IsExtensionSupported (const std::string &szExtension)
Returns whether a given file extension is supported by ASSIMP.
bool | IsExtensionSupported (const char *szExtension)
Returns whether a given file extension is supported by ASSIMP.
const aiScene * | ReadFile (const std::string &pFile, unsigned int pFlags)
Reads the given file and returns its contents if successful.
const aiScene * | ReadFile (const char *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 | 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)
Check whether a given set of postprocessing flags is supported.
~Importer ()
Destructor.

Protected Attributes

ImporterPimpl * | pimpl

Friends

const aiScene * | aiImportFileEx (const char *, unsigned int, aiFileIO *)
Reads the given file using user-defined I/O functions and returns its content.
const aiScene * | aiImportFileFromMemory (const char *, unsigned int, unsigned int, const char *)
Reads the given file from a given memory buffer,.
class | BaseProcess
class | BatchLoader

Detailed Description

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.

BaseImporter* Assimp::Importer::FindLoader ( const char * szExtension )

Find the loader corresponding to a specific file extension.

This is quite similar to IsExtensionSupported() except a BaseImporter instance is returned.

Parameters:
szExtension Extension to be checked, cases insensitive, must include a trailing dot.
Returns:
NULL if there is no loader for the extension.

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

AI_FORCE_INLINE void Assimp::Importer::GetExtensionList ( std::string & szOut ) [inline]

Get a full list of all file extensions supported by ASSIMP.

This function is provided for backward compatibility. See the aiString version for detailled docs.

See also:
GetExtensionList(aiString&)

void Assimp::Importer::GetExtensionList ( aiString & szOut )

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.

Parameters:
szOut String to receive the extension list. It just means there is a loader which handles such files. Format of the list: "*.3ds;*.obj;*.dae".

IOSystem* Assimp::Importer::GetIOHandler ( )

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

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.

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:
Under windows, deleting the returned scene manually will probably not work properly in applications using static runtime linkage.

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

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

AI_FORCE_INLINE bool Assimp::Importer::IsExtensionSupported ( const std::string & szExtension ) [inline]

Returns whether a given file extension is supported by ASSIMP.

This function is provided for backward compatibility. See the const char* version for detailled docs.

See also:
IsExtensionSupported(const char*)

bool Assimp::Importer::IsExtensionSupported ( const char * szExtension )

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

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::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. However, to enable automatic detection of the file format, the input path *must* not have an extension at all.

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

In this mode the data structure is validated after every single post processing step to make sure everyone modifies the data structure in the defined manner. This is a debug feature and not intended for public use.

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::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).
iValue | New value of the property
bWasExisting | Optional pointer to receive true if the property was set before. The new value replaced the old 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 )

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 not supported.

Friends And Related Function Documentation

const aiScene* aiImportFileEx | ( | const char * | ,
 |  | unsigned | int,
 |  | aiFileIO * |  |
 | ) |  |  | [friend]

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.
Returns:
Pointer to the imported data or NULL if the import failed.
Note:
Include <aiFileIO.h> for the definition of aiFileIO.

const aiScene* aiImportFileFromMemory | ( | const char * | ,
 |  | unsigned | int,
 |  | unsigned | int,
 |  | const char * |  |
 | ) |  |  | [friend]

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. f you need the full functionality, provide a custom IOSystem to make Assimp find these files.

friend class BaseProcess [friend]

friend class BatchLoader [friend]

Member Data Documentation

ImporterPimpl* Assimp::Importer::pimpl [protected]

The documentation for this class was generated from the following file:
  • assimp.hpp


assimp: Assimp::Intern::AllocateFromAssimpHeap Struct Reference

Assimp::Intern::AllocateFromAssimpHeap

Assimp::Intern::AllocateFromAssimpHeap Struct Reference

Internal helper class to utilize our internal new/delete routines for allocating object of this and derived classes. More...

Inherited by Assimp::IOStream, Assimp::IOSystem, Assimp::Logger, and Assimp::LogStream.

List of all members.

Public Member Functions

void | operator delete (void *data)
void | operator delete[] (void *data)
void * | operator new (size_t num_bytes)
void * | operator new[] (size_t num_bytes)

Detailed Description

Internal helper class to utilize our internal new/delete routines for allocating object of this and derived classes.

By doing this you can safely share class objects between Assimp and the application - it works even over DLL boundaries. A good example is the IOSystem where the application allocates its custom IOSystem, then calls Importer::SetIOSystem(). When the Importer destructs, Assimp calls operator delete on the stored IOSystem. If it lies on a different heap than Assimp is working with, the application is determined to crash.

Member Function Documentation

void Assimp::Intern::AllocateFromAssimpHeap::operator delete ( void * data )

void Assimp::Intern::AllocateFromAssimpHeap::operator delete[] ( void * data )

void* Assimp::Intern::AllocateFromAssimpHeap::operator new ( size_t num_bytes )

void* Assimp::Intern::AllocateFromAssimpHeap::operator new[] ( size_t num_bytes )

The documentation for this struct was generated from the following file:
  • aiTypes.h
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Assimp::Interpolator< T > Struct Template Reference

Assimp::Interpolator

Assimp::Interpolator< T > Struct Template Reference

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 >

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:
  • aiAnim.h


assimp: Assimp::IOStream Class Reference

Assimp::IOStream

Assimp::IOStream Class Reference

Class to handle file I/O for C++. More...

Inherits Assimp::Intern::AllocateFromAssimpHeap.

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

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


assimp: Assimp::IOSystem Class Reference

Assimp::IOSystem

Assimp::IOSystem Class Reference

Interface to the file system. More...

Inherits Assimp::Intern::AllocateFromAssimpHeap.

List of all members.

Public Member Functions

virtual void | Close (IOStream *pFile)=0
Closes the given file and releases all resources associated with it.
bool | ComparePaths (const std::string &one, const std::string &second) const
For backward compatibility.
virtual bool | ComparePaths (const char *one, const char *second) const
Compares two paths and check whether the point to identical files.
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.
IOStream * | Open (const std::string &pFile, const std::string &pMode=std::string("rb"))
For backward compatibility.
virtual IOStream * | Open (const char *pFile, const char *pMode="rb")=0
Open a new file with a given path.
virtual | ~IOSystem ()
Virtual destructor.

Detailed Description

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


assimp: Assimp::Logger Class Reference

Assimp::Logger

Assimp::Logger Class Reference

Abstract interface for logger implementations. More...

Inherits Assimp::Intern::AllocateFromAssimpHeap.

Inherited by Assimp::DefaultLogger, and Assimp::NullLogger.

List of all members.

Public Types

Public Member Functions

virtual bool | attachStream (LogStream *pStream, unsigned int severity=DEBUGGING|ERR|WARN|INFO)=0
Attach a new logstream.
void | debug (const std::string &message)
Writes a debug 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 std::string &message)
Writes an error message.
LogSeverity | getLogSeverity () const
Get the current log severity.
void | info (const std::string &message)
Writes a info message.
void | setLogSeverity (LogSeverity log_severity)
Set a new log severity.
void | warn (const std::string &message)
Writes a warning message.
virtual | ~Logger ()
Virtual destructor.

Protected Member Functions

Logger (LogSeverity severity)
Construction with a given log severity.
Logger ()
Default constructor.
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

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.

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

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

Parameters:
pStream | Logstream 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 std::string & message )

Writes a debug message.

Parameters:
message Debug message

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 | Logstream 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 dettached, false otherwise.

Implemented in Assimp::DefaultLogger, and Assimp::NullLogger.

void Assimp::Logger::error ( const std::string & 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 )

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 (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::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 (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::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 std::string & message )

Writes a warning message.

Parameters:
message Warn message

Member Data Documentation

LogSeverity Assimp::Logger::m_Severity [protected]

Logger severity.

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


assimp: Assimp::LogStream Class Reference

Assimp::LogStream

Assimp::LogStream Class Reference

Abstract interface for log stream implementations. More...

Inherits Assimp::Intern::AllocateFromAssimpHeap.

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

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

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.h
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Assimp::NullLogger Class Reference

Assimp::NullLogger

Assimp::NullLogger Class Reference

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

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.h
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Hierarchical Index

Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
  • aiAnimation
  • aiBone
  • aiCamera
  • aiColor3D
  • aiColor4D
  • aiFace
  • aiFile
  • aiFileIO
  • aiLight
  • aiLogStream
  • aiMaterial
  • aiMatrix3x3
  • aiMatrix4x4
  • aiMesh
  • aiNode
  • aiNodeAnim
  • aiPlane
  • aiQuaternion
  • aiQuatKey
  • aiRay
  • aiScene
  • aiString
  • aiTexel
  • aiTexture
  • aiUVTransform
  • aiVector2D
  • aiVector3D
  • aiVectorKey
  • aiVertexWeight
  • Assimp::Importer
  • Assimp::Intern::AllocateFromAssimpHeap
    • Assimp::IOStream
    • Assimp::IOSystem
    • Assimp::Logger
      • Assimp::DefaultLogger
      • Assimp::NullLogger
    • Assimp::LogStream
  • Assimp::Interpolator< 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 : aiTexel , aiPlane , aiColor4D
  • a1 : aiMatrix3x3 , aiMatrix4x4
  • a2 : aiMatrix3x3 , aiMatrix4x4
  • a3 : aiMatrix3x3 , aiMatrix4x4
  • a4 : aiMatrix4x4
  • achFormatHint : aiTexture
  • aiAnimation() : aiAnimation
  • aiBone() : aiBone
  • aiCamera() : aiCamera
  • aiColor3D() : aiColor3D
  • aiColor4D() : aiColor4D
  • aiFace() : aiFace
  • aiImportFileEx : Assimp::Importer
  • aiImportFileFromMemory : Assimp::Importer
  • aiLight() : aiLight
  • aiMaterial() : aiMaterial
  • aiMatrix3x3() : aiMatrix3x3
  • aiMatrix4x4() : aiMatrix4x4
  • aiMesh() : aiMesh
  • aiNode() : aiNode
  • aiNodeAnim() : aiNodeAnim
  • aiPlane() : aiPlane
  • aiQuaternion() : aiQuaternion
  • aiQuatKey() : aiQuatKey
  • aiRay() : aiRay
  • aiScene() : aiScene
  • aiString() : aiString
  • aiTexture() : aiTexture
  • aiUVTransform() : aiUVTransform
  • aiVector2D() : aiVector2D
  • aiVector3D() : aiVector3D
  • aiVectorKey() : aiVectorKey
  • aiVertexWeight() : aiVertexWeight
  • Append() : aiString
  • ApplyPostProcessing() : Assimp::Importer
  • attachStream()
: Assimp::NullLogger
, Assimp::Logger
, Assimp::DefaultLogger


assimp: Namespace Index

  • Namespace List
  • Namespace Members

Namespace List

Here is a list of all namespaces with brief descriptions:
Assimp
Assimp::Intern


assimp: Assimp Namespace Reference

  • Namespace List
  • Namespace Members

Assimp Namespace Reference

Namespaces

namespace | Intern

Classes

class | DefaultLogger
Primary logging implementation of Assimp. More...
class | Importer
The Importer class forms an C++ interface to the functionality of the Open Asset Import Library. More...
struct | Interpolator
Utility class to simplify interpolations of various data types. More...
class | IOStream
Class to handle file I/O for C++. More...
class | IOSystem
Interface to the file system. More...
class | Logger
Abstract interface for logger implementations. More...
class | LogStream
Abstract interface for log stream implementations. More...
class | NullLogger
Empty logging implementation. More...

Functions

void | aiAssert (bool expression, const std::string &message, unsigned int uiLine, const std::string &file)
ASSIMP specific assertion test, just works in debug mode.

Function Documentation

void Assimp::aiAssert | ( | bool | expression,
 |  | const std::string & | message,
 |  | unsigned int | uiLine,
 |  | const std::string & | file
 | ) |  |

ASSIMP specific assertion test, just works in debug mode.

Parameters:
uiLine | Line in file
file | Source file


assimp: Assimp::Intern Namespace Reference

  • Namespace List
  • Namespace Members
Assimp::Intern

Assimp::Intern Namespace Reference

Classes

struct AllocateFromAssimpHeap
Internal helper class to utilize our internal new/delete routines for allocating object of this and derived classes. More...
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
Here is a list of all namespace members with links to the namespace documentation for each member:

  • aiAssert() : Assimp
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: File Index

  • File List
  • File Members

File List

Here is a list of all files with brief descriptions:
aiAnim.h | Defines the data structures in which the imported animations are returned
aiAssert.h |
aiCamera.h | Defines the aiCamera data structure
aiConfig.h | Defines constants for configurable properties for the library
aiDefines.h | Assimp build configuration setup
aiFileIO.h | Defines generic C routines to access memory-mapped files
aiLight.h | Defines the aiLight data structure
aiMaterial.h | Defines the material system of the library
aiMaterial.inl | Defines the C++ getters for the material system
aiMatrix3x3.h | Definition of a 3x3 matrix, including operators when compiling in C++
aiMatrix3x3.inl | Inline implementation of the 3x3 matrix operators
aiMatrix4x4.h | 4x4 matrix structure, including operators when compiling in C++
aiMatrix4x4.inl | Inline implementation of the 4x4 matrix operators
aiMesh.h | Declares the data structures in which the imported geometry is returned by ASSIMP: aiMesh, aiFace and aiBone data structures
aiPostProcess.h | Definitions for import post processing steps
aiQuaternion.h | Quaternion structure, including operators when compiling in C++
aiScene.h | Defines the data structures in which the imported scene is returned
aiTexture.h | Defines texture helper structures for the library
aiTypes.h | Basic data types and primitives, such as vectors or colors
aiVector2D.h | 2D vector structure, including operators when compiling in C++
aiVector3D.h | 3D vector structure, including operators when compiling in C++
aiVector3D.inl | Inline implementation of aiVector3D operators
aiVersion.h | Functions to query the version of the Assimp runtime, check compile flags,
assimp.h | Defines the C-API to the Open Asset Import Library
assimp.hpp | Defines the C++-API to the Open Asset Import Library
DefaultLogger.h |
dox.h | General documentation built from a doxygen comment
IOStream.h | File I/O wrappers for C++
IOSystem.h | File system wrapper for C++
Logger.h | Abstract base class 'Logger', base of the logging system
LogStream.h | Abstract base class 'LogStream', representing an output log stream
NullLogger.h | Dummy logger
poppack1.h |
pstdint.h |
pushpack1.h |
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: aiAnim.h File Reference

  • File List
  • File Members

aiAnim.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 | 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 >
Utility class to simplify interpolations of various data types. More...

Namespaces

namespace | Assimp

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.

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiAssert.h File Reference

  • File List
  • File Members

aiAssert.h File Reference

Namespaces

namespace | Assimp

Functions

void | Assimp::aiAssert (bool expression, const std::string &message, unsigned int uiLine, const std::string &file)
ASSIMP specific assertion test, just works in debug mode.

Detailed Description

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiCamera.h File Reference

  • File List
  • File Members

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

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiConfig.h File Reference

  • File List
  • File Members

aiConfig.h File Reference

Defines constants for configurable properties for the library. More...

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 pipeline by using the RemoveComponent post processing 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

Enumeration Type Documentation

enum aiComponent

Enumerates components of the aiScene and aiMesh data structures that can be excluded from the import pipeline by using the RemoveComponent post processing 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 scenegraph nodes corresponding to the bones 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 scenegraph nodes corresponding to the bones are NOT removed. use the aiProcess_OptimizeGraph step to do this

aiComponent_CAMERAS Removes all light sources (aiScene::mCameras).

The scenegraph nodes corresponding to the bones 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.

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiDefines.h File Reference

  • File List
  • File Members

aiDefines.h File Reference

Assimp build configuration setup. More...

Detailed Description

Assimp build configuration setup.

See the notes in the comment blocks to find out how to customize _your_ Assimp build.

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiFileIO.h File Reference

  • File List
  • File Members

aiFileIO.h File Reference

Defines generic C routines to access memory-mapped files. More...

Classes

struct | aiFile
Represents a read/write file. More...
struct | aiFileIO
Defines Assimp's way of accessing files. 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

Detailed Description

Defines generic C routines to access memory-mapped files.

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

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiLight.h File Reference

  • File List
  • File Members

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

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiMaterial.h File Reference

  • File List
  • File Members

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

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. 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
Defines how an UV channel is transformed.

Detailed Description

Defines the material system of the library.

Enumeration Type Documentation

enum aiBlendMode

Defines alpha-blend flags.

If you're familiar with OpenGL or D3D, these flags aren't new to you. The 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 u1|v1.
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 u1|v1 if (u-(u1))2 is zero and 1-(u1)|1-(v1) 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 grey-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 differenciate 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. It's intensity is not affected by incoming light.

aiTextureType_REFLECTION Reflection texture.

Contains the color of a perfect mirror reflection. Rarely used, almost nevery 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 aiColor4D PACK_STRUCT

Defines how an UV channel is transformed.

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

Represents a color in Red-Green-Blue space.

Represents a ray.

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.

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiMaterial.inl File Reference

  • File List
  • File Members

aiMaterial.inl File Reference

Defines the C++ getters for the material system. More...

Detailed Description

Defines the C++ getters for the material system.

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiMatrix3x3.h File Reference

  • File List
  • File Members

aiMatrix3x3.h File Reference

Definition of a 3x3 matrix, including operators when compiling in C++. More...

Classes

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

Detailed Description

Definition of a 3x3 matrix, including operators when compiling in C++.

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiMatrix3x3.inl File Reference

  • File List
  • File Members

aiMatrix3x3.inl File Reference

Inline implementation of the 3x3 matrix operators. More...

Detailed Description

Inline implementation of the 3x3 matrix operators.

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiMatrix4x4.h File Reference

  • File List
  • File Members

aiMatrix4x4.h File Reference

4x4 matrix structure, including operators when compiling in C++ More...

Classes

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

Variables

struct aiMatrix4x4 | PACK_STRUCT
Represents a row-major 4x4 matrix, use this for homogeneous coordinates.

Detailed Description

4x4 matrix structure, including operators when compiling in C++

Variable Documentation

struct aiMatrix4x4 PACK_STRUCT

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

There's much confusion about matrix layouts (colum vs. row order). This is *always* a row-major matrix. Even with the aiProcess_ConvertToLeftHanded flag.

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiMatrix4x4.inl File Reference

  • File List
  • File Members

aiMatrix4x4.inl File Reference

Inline implementation of the 4x4 matrix operators. More...

Detailed Description

Inline implementation of the 4x4 matrix operators.

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiMesh.h File Reference

  • File List
  • File Members

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

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.

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.

Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: aiPostProcess.h File Reference

  • File List
  • File Members

aiPostProcess.h File Reference

Definitions for import post processing steps. More...

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
}
Defines the flags for all possible post processing steps. More...

Detailed Description

Definitions for import post processing steps.

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 let the default value. Thanks.

aiProcess_JoinIdenticalVertices
Identifies and joins identical vertex data sets within all imported meshes.

After this step is run each mesh does contain only unique vertices anymore, so a vertex is possibly 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 for example OpenGL prefers. In this space, +X points to the right, +Z points towards the viewer and 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 boundles 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 all higher faces to 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. Especially vertex colors are rarely used today ... . Calling this step to remove unrequired stuff from the pipeline as early as possible results in an increased performance and a better 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 it's purpose is usually misunderstood. Consider the following case: a 3d model has been exported from a CAD app, it has per-face vertex colors. Vertex positions can't be shared, thus the aiProcess_JoinIdenticalVertices step fails to optimize the data. Just because 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 optimzations.

aiProcess_GenNormals
Generates normals for all faces of all meshes.

This is ignored if normals are already there at the time where 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 in other words, enforces 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 where this flag is evaluated. Model importers try to load them from the source file, so they're usually already there.

This flag may (of course) 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 a 'hard' seam between two faces. Using a decent angle here (e.g. 80°) results in very good visual appearance.

aiProcess_SplitLargeMeshes
Splits large meshes into smaller submeshes

This is quite useful for realtime rendering where the number of triangles which can be maximally processed in a single draw-call is usually 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 not if there's nothing 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 does still contain nodes, however, there is only a root node with children, each one referencing only one mesh, 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 that have no 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 will be zeroed.
aiProcess_LimitBoneWeights
Limits the number of bones simultaneously affecting a single vertex to a maximum value.

If any vertex is affected by more than that 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 aiConfig.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 for 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 to capture Assimp's log output if you use this flag, so you can easily find ot what's actually wrong if a file fails the validation. The validator is quite rude and will find *all* inconsistencies in the data structure ... plugin developers are recommended to 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. It's 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 for 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 always 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 ... the material name is one of them. So, if you're passing additional information through the content pipeline (probably using 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. 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 submeshes.

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 degenerated primitives and converts them to proper lines or points.

A face is 'degenerated' if one or more of its points are identical. To have the degenerated stuff not only detected and collapsed but also removed, try one of the following procedures:
1. (if you support lines&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 degenerated 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&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:
Degenerated 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 ... some exporters bypass the format specification and write them as degenerated triangle instead.
aiProcess_FindInvalidData
This step searches all meshes for invalid data, such as zeroed normal vectors or invalid UV coords and removes them.

This is especially useful for normals. If they are invalid, and the step recognizes this, they will be removed and can later be computed by one of the other steps.
The step will also remove meshes that are infinitely small.

aiProcess_GenUVCoords
This step converts non-UV mappings (such as spherical or cylindrical apping) 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 tha 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 father app compute the UV channels, at least 3ds max, maja, blender, lightwave, modo, ... are able to achieve this.

Note:
If this step is not requested, you'll need to process the AI_MATKEY_MAPPING<7tt> material property in order to display all assets properly.
aiProcess_TransformUVCoords
This step applies per-texture UV transformations and bakes them to stand-alone vtexture coordinate channelss.

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 new (pretransformed) UV channel which replace 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 realtime 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 duplicates with references to the first mesh.

This step takes a while, don't use it if you have no time. It's main purpose is to workaround the limitation 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 currently not support per-node material assignment to meshes, which means that identical meshes with differnent materials are currently *not* joined, although this is planned for future versions.

aiProcess_OptimizeMeshes
A postprocessing step to reduce the number of meshes.

In fact, it will reduce the number of drawcalls.

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 with no 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<7tt> 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, complex hierarchies are usually completely lost. That's not the right choice 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 boundles 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.
Output face order:

       x2

                         x0
  x1


assimp: aiQuaternion.h File Reference

  • File List
  • File Members

aiQuaternion.h File Reference

Quaternion structure, including operators when compiling in C++. More...

Classes

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

Detailed Description

Quaternion structure, including operators when compiling in C++.


assimp: aiScene.h File Reference

  • File List
  • File Members

aiScene.h File Reference

Defines the data structures in which the imported scene is returned. More...

Classes

struct | aiNode
A node in the imported hierarchy. More...
struct | aiScene
The root structure of the imported data. More...

Detailed Description

Defines the data structures in which the imported scene is returned.


assimp: aiTexture.h File Reference

  • File List
  • File Members

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

Variables

struct aiTexel | PACK_STRUCT
Helper structure to represent a texel in a ARGB8888 format.

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.

Variable Documentation

struct aiTexel PACK_STRUCT

Helper structure to represent a texel in a ARGB8888 format.

Used by aiTexture.


assimp: aiTypes.h File Reference

  • File List
  • File Members

aiTypes.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 | aiColor4D
Represents a color in Red-Green-Blue space including an alpha component. More...
struct | aiPlane
Represents a plane in a three-dimensional, euclidean space. More...
struct | aiRay
Represents a ray. More...
struct | aiString
Represents a string, zero byte terminated. More...
struct | Assimp::Intern::AllocateFromAssimpHeap
Internal helper class to utilize our internal new/delete routines for allocating object of this and derived classes. More...

Namespaces

namespace | Assimp
namespace | Assimp::Intern

Variables

const size_t | MAXLEN = 1024
namespace Assimp
struct aiPlane | PACK_STRUCT
Represents a plane in a three-dimensional, euclidean space.

Detailed Description

Basic data types and primitives, such as vectors or colors.

Variable Documentation

const size_t MAXLEN = 1024

namespace Assimp

Maximum dimension for strings, ASSIMP strings are zero terminated.

struct aiColor4D PACK_STRUCT

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

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

Represents a color in Red-Green-Blue space.

Represents a ray.


assimp: aiVector2D.h File Reference

  • File List
  • File Members

aiVector2D.h File Reference

2D vector structure, including operators when compiling in C++ More...

Classes

struct | aiVector2D
Represents a two-dimensional vector. More...

Functions

aiVector2D | operator* (const aiVector2D &v, float f)
aiVector2D | operator* (float f, const aiVector2D &v)
float | operator* (const aiVector2D &v1, const aiVector2D &v2)
aiVector2D | operator+ (const aiVector2D &v1, const aiVector2D &v2)
aiVector2D | operator- (const aiVector2D &v)
aiVector2D | operator- (const aiVector2D &v1, const aiVector2D &v2)
aiVector2D | operator/ (const aiVector2D &v, const aiVector2D &v2)
aiVector2D | operator/ (const aiVector2D &v, float f)

Variables

struct aiVector2D | PACK_STRUCT
Represents a two-dimensional vector.

Detailed Description

2D vector structure, including operators when compiling in C++

Function Documentation

aiVector2D operator* | ( | const aiVector2D & | v,
 |  | float | f |
 | ) |  |  | [inline]

aiVector2D operator* | ( | float | f,
 |  | const aiVector2D & | v |
 | ) |  |  | [inline]

float operator* | ( | const aiVector2D & | v1,
 |  | const aiVector2D & | v2 |
 | ) |  |  | [inline]

aiVector2D operator+ | ( | const aiVector2D & | v1,
 |  | const aiVector2D & | v2 |
 | ) |  |  | [inline]

aiVector2D operator- ( const aiVector2D & v ) [inline]

aiVector2D operator- | ( | const aiVector2D & | v1,
 |  | const aiVector2D & | v2 |
 | ) |  |  | [inline]

aiVector2D operator/ | ( | const aiVector2D & | v,
 |  | const aiVector2D & | v2 |
 | ) |  |  | [inline]

aiVector2D operator/ | ( | const aiVector2D & | v,
 |  | float | f |
 | ) |  |  | [inline]

Variable Documentation

struct aiVector2D PACK_STRUCT

Represents a two-dimensional vector.


assimp: aiVector3D.h File Reference

  • File List
  • File Members

aiVector3D.h File Reference

3D vector structure, including operators when compiling in C++ More...

Classes

struct | aiVector3D
Represents a three-dimensional vector. More...

Variables

struct aiVector3D | PACK_STRUCT
Represents a three-dimensional vector.

Detailed Description

3D vector structure, including operators when compiling in C++

Variable Documentation

struct aiVector3D PACK_STRUCT

Represents a three-dimensional vector.


assimp: aiVector3D.inl File Reference

  • File List
  • File Members

aiVector3D.inl File Reference

Inline implementation of aiVector3D operators. More...

Functions

AI_FORCE_INLINE aiVector3D | operator* (const aiVector3D &v, float f)
AI_FORCE_INLINE aiVector3D | operator* (float f, const aiVector3D &v)
AI_FORCE_INLINE float | operator* (const aiVector3D &v1, const aiVector3D &v2)
aiVector3D | operator* (const aiMatrix4x4 &pMatrix, const aiVector3D &pVector)
Transformation of a vector by a 4x4 matrix.
aiVector3D | operator* (const aiMatrix3x3 &pMatrix, const aiVector3D &pVector)
Transformation of a vector by a 3x3 matrix.
AI_FORCE_INLINE aiVector3D | operator+ (const aiVector3D &v1, const aiVector3D &v2)
AI_FORCE_INLINE aiVector3D | operator- (const aiVector3D &v)
AI_FORCE_INLINE aiVector3D | operator- (const aiVector3D &v1, const aiVector3D &v2)
AI_FORCE_INLINE aiVector3D | operator/ (const aiVector3D &v, const aiVector3D &v2)
AI_FORCE_INLINE aiVector3D | operator/ (const aiVector3D &v, float f)
AI_FORCE_INLINE aiVector3D | operator^ (const aiVector3D &v1, const aiVector3D &v2)

Detailed Description

Inline implementation of aiVector3D operators.

Function Documentation

AI_FORCE_INLINE aiVector3D operator* | ( | const aiVector3D & | v,
 |  | float | f
 | ) |  |

AI_FORCE_INLINE aiVector3D operator* | ( | float | f,
 |  | const aiVector3D & | v
 | ) |  |

AI_FORCE_INLINE float operator* | ( | const aiVector3D & | v1,
 |  | const aiVector3D & | v2
 | ) |  |

aiVector3D operator* | ( | const aiMatrix4x4 & | pMatrix,
 |  | const aiVector3D & | pVector |
 | ) |  |  | [inline]

Transformation of a vector by a 4x4 matrix.

aiVector3D operator* | ( | const aiMatrix3x3 & | pMatrix,
 |  | const aiVector3D & | pVector |
 | ) |  |  | [inline]

Transformation of a vector by a 3x3 matrix.

AI_FORCE_INLINE aiVector3D operator+ | ( | const aiVector3D & | v1,
 |  | const aiVector3D & | v2
 | ) |  |

AI_FORCE_INLINE aiVector3D operator- ( const aiVector3D & v )

AI_FORCE_INLINE aiVector3D operator- | ( | const aiVector3D & | v1,
 |  | const aiVector3D & | v2
 | ) |  |

AI_FORCE_INLINE aiVector3D operator/ | ( | const aiVector3D & | v,
 |  | const aiVector3D & | v2
 | ) |  |

AI_FORCE_INLINE aiVector3D operator/ | ( | const aiVector3D & | v,
 |  | float | f
 | ) |  |

AI_FORCE_INLINE aiVector3D operator^ | ( | const aiVector3D & | v1,
 |  | const aiVector3D & | v2
 | ) |  |


assimp: aiVersion.h File Reference

  • File List
  • File Members

aiVersion.h File Reference

Functions to query the version of the Assimp runtime, check compile flags, . More...

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.

Detailed Description

Functions to query the version of the Assimp runtime, check compile flags, .

..

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: assimp.h File Reference

  • File List
  • File Members

assimp.h File Reference

Defines the C-API to the Open Asset Import Library. More...

Classes

struct | aiLogStream
Represents a log stream. More...

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 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 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 * | aiImportFileFromMemory (const char *pBuffer, unsigned int pLength, unsigned int pFlags, const char *pHint)
Reads the given file from a given memory buffer,.
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 | aiSetImportPropertyFloat (const char *szName, float value)
Set a floating-point property.
ASSIMP_API void | aiSetImportPropertyInteger (const char *szName, int value)
Set an integer property.
ASSIMP_API void | aiSetImportPropertyString (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.

Detailed Description

Defines the C-API to the Open Asset Import Library.

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 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 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:

    aiLogStreamCallback c = aiGetPredefinedLogStream(aiDefaultLogStream_FILE,"log.txt",NULL);
    if (NULL != c) {
       aiAttachLogStream(c);
    }

Parameters:
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.
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* 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. f you need the full functionality, provide a custom IOSystem to make Assimp find these files.

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 aiSetImportPropertyFloat | ( | 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 aiConfig.h header file (AI_CONFIG_XXX).
value | New value for the property

ASSIMP_API void aiSetImportPropertyInteger | ( | 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 aiConfig.h header file (AI_CONFIG_XXX).
value | New value for the property

ASSIMP_API void aiSetImportPropertyString | ( | 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:
szName | Name of the configuration property to be set. All supported public properties are defined in the aiConfig.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: assimp.hpp File Reference

  • File List
  • File Members

assimp.hpp File Reference

Defines the C++-API to the Open Asset Import Library. More...

Classes

class | Assimp::Importer
The Importer class forms an C++ interface to the functionality of the Open Asset Import Library. More...

Namespaces

namespace | Assimp

Functions

ASSIMP_API const aiScene * | aiImportFileEx (const char *, unsigned int, aiFileIO *)
ASSIMP_API const aiScene * | aiImportFileFromMemory (const char *, unsigned int, unsigned int, const char *)

Detailed Description

Defines the C++-API to the Open Asset Import Library.

Function Documentation

ASSIMP_API const aiScene* aiImportFileEx | ( | const char * | ,
 |  | unsigned | int,
 |  | aiFileIO * |
 | ) |  |

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.
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* aiImportFileFromMemory | ( | const char * | ,
 |  | unsigned | int,
 |  | unsigned | int,
 |  | const char * |
 | ) |  |

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. f you need the full functionality, provide a custom IOSystem to make Assimp find these files.


assimp: DefaultLogger.h File Reference

  • File List
  • File Members

DefaultLogger.h File Reference

Classes

class | Assimp::DefaultLogger
Primary logging implementation of Assimp. More...

Namespaces

namespace | Assimp

Detailed Description

Generated on Sun Jul 19 17:01:49 2009 for assimp by doxygen 1.5.8


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: IOStream.h File Reference

  • File List
  • File Members

IOStream.h File Reference

File I/O wrappers for C++. More...

Classes

class | Assimp::IOStream
Class to handle file I/O for C++. More...

Namespaces

namespace | Assimp

Detailed Description

File I/O wrappers for C++.


assimp: IOSystem.h File Reference

  • File List
  • File Members

IOSystem.h File Reference

File system wrapper for C++. More...

Classes

class | Assimp::IOSystem
Interface to the file system. More...

Namespaces

namespace | Assimp

Detailed Description

File system wrapper for C++.

Inherit this class to supply custom file handling logic to the Import library.


assimp: Logger.h File Reference

  • File List
  • File Members

Logger.h File Reference

Abstract base class 'Logger', base of the logging system. More...

Classes

class | Assimp::Logger
Abstract interface for logger implementations. More...

Namespaces

namespace | Assimp

Detailed Description

Abstract base class 'Logger', base of the logging system.


assimp: LogStream.h File Reference

  • File List
  • File Members

LogStream.h File Reference

Abstract base class 'LogStream', representing an output log stream. More...

Classes

class | Assimp::LogStream
Abstract interface for log stream implementations. More...

Namespaces

namespace | Assimp

Detailed Description

Abstract base class 'LogStream', representing an output log stream.


assimp: NullLogger.h File Reference

  • File List
  • File Members

NullLogger.h File Reference

Dummy logger. More...

Classes

class | Assimp::NullLogger
Empty logging implementation. More...

Namespaces

namespace | Assimp

Detailed Description

Dummy logger.


assimp: poppack1.h File Reference

  • File List
  • File Members

poppack1.h File Reference

Generated on Sun Jul 19 17:01:49 2009 for assimp by doxygen 1.5.8


assimp: pstdint.h File Reference

  • File List
  • File Members

pstdint.h File Reference

Typedefs

typedef int_least16_t | int_fast16_t
typedef int_least32_t | int_fast32_t
typedef int_least8_t | int_fast8_t
typedef int16_t | int_least16_t
typedef int32_t | int_least32_t
typedef int8_t | int_least8_t
typedef int32_t | intmax_t
typedef ptrdiff_t | intptr_t
typedef uint_least16_t | uint_fast16_t
typedef uint_least32_t | uint_fast32_t
typedef uint_least8_t | uint_fast8_t
typedef uint16_t | uint_least16_t
typedef uint32_t | uint_least32_t
typedef uint8_t | uint_least8_t
typedef uint32_t | uintmax_t

Typedef Documentation

typedef int_least16_t int_fast16_t

typedef int_least32_t int_fast32_t

typedef int_least8_t int_fast8_t

typedef int16_t int_least16_t

typedef int32_t int_least32_t

typedef int8_t int_least8_t

typedef int32_t intmax_t

typedef ptrdiff_t intptr_t

typedef uint_least16_t uint_fast16_t

typedef uint_least32_t uint_fast32_t

typedef uint_least8_t uint_fast8_t

typedef uint16_t uint_least16_t

typedef uint32_t uint_least32_t

typedef uint8_t uint_least8_t

typedef uint32_t uintmax_t


assimp: pushpack1.h File Reference

  • File List
  • File Members

pushpack1.h File Reference

Generated on Sun Jul 19 17:01:49 2009 for assimp by doxygen 1.5.8


assimp: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • i
  • m
  • o
  • p
  • u
Here is a list of all file members with links to the files they belong to:

- _ -

  • _aiAnimBehaviour_Force32Bit : aiAnim.h
  • _aiComponent_Force32Bit : aiConfig.h
  • _aiLightSource_Force32Bit : aiLight.h
  • _aiPrimitiveType_Force32Bit : aiMesh.h

- a -

  • aiAnimBehaviour : aiAnim.h
  • aiAnimBehaviour_CONSTANT : aiAnim.h
  • aiAnimBehaviour_DEFAULT : aiAnim.h
  • aiAnimBehaviour_LINEAR : aiAnim.h
  • aiAnimBehaviour_REPEAT : aiAnim.h
  • aiApplyPostProcessing() : assimp.h
  • aiAttachLogStream() : assimp.h
  • aiBlendMode : aiMaterial.h
  • aiBlendMode_Additive : aiMaterial.h
  • aiBlendMode_Default : aiMaterial.h
  • aiBool : assimp.h
  • aiComponent : aiConfig.h
  • aiComponent_ANIMATIONS : aiConfig.h
  • aiComponent_BONEWEIGHTS : aiConfig.h
  • aiComponent_CAMERAS : aiConfig.h
  • aiComponent_COLORS : aiConfig.h
  • aiComponent_LIGHTS : aiConfig.h
  • aiComponent_MATERIALS : aiConfig.h
  • aiComponent_MESHES : aiConfig.h
  • aiComponent_NORMALS : aiConfig.h
  • aiComponent_TANGENTS_AND_BITANGENTS : aiConfig.h
  • aiComponent_TEXCOORDS : aiConfig.h
  • aiComponent_TEXTURES : aiConfig.h
  • aiCreateQuaternionFromMatrix() : assimp.h
  • aiDecomposeMatrix() : assimp.h
  • aiDetachAllLogStreams() : assimp.h
  • aiDetachLogStream() : assimp.h
  • aiEnableVerboseLogging() : assimp.h
  • aiFileCloseProc : aiFileIO.h
  • aiFileFlushProc : aiFileIO.h
  • aiFileOpenProc : aiFileIO.h
  • aiFileReadProc : aiFileIO.h
  • aiFileSeek : aiFileIO.h
  • aiFileTellProc : aiFileIO.h
  • aiFileWriteProc : aiFileIO.h
  • aiGetCompileFlags() : aiVersion.h
  • aiGetErrorString() : assimp.h
  • aiGetExtensionList() : assimp.h
  • aiGetLegalString() : aiVersion.h
  • aiGetMemoryRequirements() : assimp.h
  • aiGetPredefinedLogStream() : assimp.h
  • aiGetVersionMajor() : aiVersion.h
  • aiGetVersionMinor() : aiVersion.h
  • aiGetVersionRevision() : aiVersion.h
  • aiIdentityMatrix3() : assimp.h
  • aiIdentityMatrix4() : assimp.h
  • aiImportFile() : assimp.h
  • aiImportFileEx() : assimp.h , assimp.hpp
  • aiImportFileFromMemory() : assimp.h , assimp.hpp
  • aiIsExtensionSupported() : assimp.h
  • aiLightSource_DIRECTIONAL : aiLight.h
  • aiLightSource_POINT : aiLight.h
  • aiLightSource_SPOT : aiLight.h
  • aiLightSource_UNDEFINED : aiLight.h
  • aiLightSourceType : aiLight.h
  • aiLogStreamCallback : assimp.h
  • aiMultiplyMatrix3() : assimp.h
  • aiMultiplyMatrix4() : assimp.h
  • aiPostProcessSteps : aiPostProcess.h
  • aiPrimitiveType : aiMesh.h
  • aiPrimitiveType_LINE : aiMesh.h
  • aiPrimitiveType_POINT : aiMesh.h
  • aiPrimitiveType_POLYGON : aiMesh.h
  • aiPrimitiveType_TRIANGLE : aiMesh.h
  • aiProcess_CalcTangentSpace : aiPostProcess.h
  • aiProcess_FindDegenerates : aiPostProcess.h
  • aiProcess_FindInstances : aiPostProcess.h
  • aiProcess_FindInvalidData : aiPostProcess.h
  • aiProcess_FixInfacingNormals : aiPostProcess.h
  • aiProcess_FlipUVs : aiPostProcess.h
  • aiProcess_FlipWindingOrder : aiPostProcess.h
  • aiProcess_GenNormals : aiPostProcess.h
  • aiProcess_GenSmoothNormals : aiPostProcess.h
  • aiProcess_GenUVCoords : aiPostProcess.h
  • aiProcess_ImproveCacheLocality : aiPostProcess.h
  • aiProcess_JoinIdenticalVertices : aiPostProcess.h
  • aiProcess_LimitBoneWeights : aiPostProcess.h
  • aiProcess_MakeLeftHanded : aiPostProcess.h
  • aiProcess_OptimizeGraph : aiPostProcess.h
  • aiProcess_OptimizeMeshes : aiPostProcess.h
  • aiProcess_PreTransformVertices : aiPostProcess.h
  • aiProcess_RemoveComponent : aiPostProcess.h
  • aiProcess_RemoveRedundantMaterials : aiPostProcess.h
  • aiProcess_SortByPType : aiPostProcess.h
  • aiProcess_SplitLargeMeshes : aiPostProcess.h
  • aiProcess_TransformUVCoords : aiPostProcess.h
  • aiProcess_Triangulate : aiPostProcess.h
  • aiProcess_ValidateDataStructure : aiPostProcess.h
  • aiReleaseImport() : assimp.h
  • aiSetImportPropertyFloat() : assimp.h
  • aiSetImportPropertyInteger() : assimp.h
  • aiSetImportPropertyString() : assimp.h
  • aiShadingMode : aiMaterial.h
  • aiShadingMode_Blinn : aiMaterial.h
  • aiShadingMode_CookTorrance : aiMaterial.h
  • aiShadingMode_Flat : aiMaterial.h
  • aiShadingMode_Fresnel : aiMaterial.h
  • aiShadingMode_Gouraud : aiMaterial.h
  • aiShadingMode_Minnaert : aiMaterial.h
  • aiShadingMode_NoShading : aiMaterial.h
  • aiShadingMode_OrenNayar : aiMaterial.h
  • aiShadingMode_Phong : aiMaterial.h
  • aiShadingMode_Toon : aiMaterial.h
  • aiTextureFlags : aiMaterial.h
  • aiTextureFlags_IgnoreAlpha : aiMaterial.h
  • aiTextureFlags_Invert : aiMaterial.h
  • aiTextureFlags_UseAlpha : aiMaterial.h
  • aiTextureMapMode : aiMaterial.h
  • aiTextureMapMode_Clamp : aiMaterial.h
  • aiTextureMapMode_Decal : aiMaterial.h
  • aiTextureMapMode_Mirror : aiMaterial.h
  • aiTextureMapMode_Wrap : aiMaterial.h
  • aiTextureMapping : aiMaterial.h
  • aiTextureMapping_BOX : aiMaterial.h
  • aiTextureMapping_CYLINDER : aiMaterial.h
  • aiTextureMapping_OTHER : aiMaterial.h
  • aiTextureMapping_PLANE : aiMaterial.h
  • aiTextureMapping_SPHERE : aiMaterial.h
  • aiTextureMapping_UV : aiMaterial.h
  • aiTextureOp : aiMaterial.h
  • aiTextureOp_Add : aiMaterial.h
  • aiTextureOp_Divide : aiMaterial.h
  • aiTextureOp_Multiply : aiMaterial.h
  • aiTextureOp_SignedAdd : aiMaterial.h
  • aiTextureOp_SmoothAdd : aiMaterial.h
  • aiTextureOp_Subtract : aiMaterial.h
  • aiTextureType : aiMaterial.h
  • aiTextureType_AMBIENT : aiMaterial.h
  • aiTextureType_DIFFUSE : aiMaterial.h
  • aiTextureType_DISPLACEMENT : aiMaterial.h
  • aiTextureType_EMISSIVE : aiMaterial.h
  • aiTextureType_HEIGHT : aiMaterial.h
  • aiTextureType_LIGHTMAP : aiMaterial.h
  • aiTextureType_NONE : aiMaterial.h
  • aiTextureType_NORMALS : aiMaterial.h
  • aiTextureType_OPACITY : aiMaterial.h
  • aiTextureType_REFLECTION : aiMaterial.h
  • aiTextureType_SHININESS : aiMaterial.h
  • aiTextureType_SPECULAR : aiMaterial.h
  • aiTextureType_UNKNOWN : aiMaterial.h
  • aiTransformVecByMatrix3() : assimp.h
  • aiTransformVecByMatrix4() : assimp.h
  • aiTransposeMatrix3() : assimp.h
  • aiTransposeMatrix4() : assimp.h
  • aiUserData : aiFileIO.h

- i -

  • int_fast16_t : pstdint.h
  • int_fast32_t : pstdint.h
  • int_fast8_t : pstdint.h
  • int_least16_t : pstdint.h
  • int_least32_t : pstdint.h
  • int_least8_t : pstdint.h
  • intmax_t : pstdint.h
  • intptr_t : pstdint.h

- m -

  • MAXLEN : aiTypes.h

- o -

  • operator*() : aiVector2D.h , aiVector3D.inl , aiVector2D.h , aiVector3D.inl
  • operator+() : aiVector2D.h , aiVector3D.inl
  • operator-() : aiVector2D.h , aiVector3D.inl , aiVector2D.h , aiVector3D.inl
  • operator/() : aiVector3D.inl , aiVector2D.h , aiVector3D.inl
  • operator^() : aiVector3D.inl

- p -

  • PACK_STRUCT : aiMaterial.h , aiVector3D.h , aiVector2D.h , aiTypes.h , aiTexture.h , aiMatrix4x4.h

- u -

  • uint_fast16_t : pstdint.h
  • uint_fast32_t : pstdint.h
  • uint_fast8_t : pstdint.h
  • uint_least16_t : pstdint.h
  • uint_least32_t : pstdint.h
  • uint_least8_t : pstdint.h
  • uintmax_t : pstdint.h
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Member List

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 std::string &message) | Assimp::Logger |
DEBUGGING enum value | Assimp::Logger |
detatchStream(LogStream *pStream, unsigned int severity) | Assimp::DefaultLogger | [virtual]
ERR enum value | Assimp::Logger |
error(const std::string &message) | Assimp::Logger |
ErrorSeverity enum name | Assimp::Logger |
get() | Assimp::DefaultLogger | [static]
getLogSeverity() const | Assimp::Logger | [inline]
info(const std::string &message) | Assimp::Logger |
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 |
operator delete(void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator delete[](void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator new(size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
operator new[](size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
set(Logger *logger) | Assimp::DefaultLogger | [static]
setLogSeverity(LogSeverity log_severity) | Assimp::Logger | [inline]
VERBOSE enum value | Assimp::Logger |
WARN enum value | Assimp::Logger |
warn(const std::string &message) | Assimp::Logger |
~Logger() | Assimp::Logger | [inline, virtual]


assimp: Member List

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]
operator delete(void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator delete[](void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator new(size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
operator new[](size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
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 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]
operator delete(void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator delete[](void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator new(size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
operator new[](size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
~IOSystem() | Assimp::IOSystem | [virtual]


assimp: Member List

Assimp::Importer Member List

This is the complete list of members for Assimp::Importer, including all inherited members.

aiImportFileEx(const char *, unsigned int, aiFileIO *) | Assimp::Importer | [friend]
aiImportFileFromMemory(const char *, unsigned int, unsigned int, const char *) | Assimp::Importer | [friend]
ApplyPostProcessing(unsigned int pFlags) | Assimp::Importer |
BaseProcess class | Assimp::Importer | [friend]
BatchLoader class | Assimp::Importer | [friend]
FindLoader(const char *szExtension) | Assimp::Importer |
FreeScene() | Assimp::Importer |
GetErrorString() const | Assimp::Importer |
GetExtensionList(aiString &szOut) | Assimp::Importer |
GetExtensionList(std::string &szOut) | Assimp::Importer | [inline]
GetIOHandler() | Assimp::Importer |
GetMemoryRequirements(aiMemoryInfo &in) const | Assimp::Importer |
GetOrphanedScene() | Assimp::Importer |
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() | Assimp::Importer |
IsExtensionSupported(const char *szExtension) | Assimp::Importer |
IsExtensionSupported(const std::string &szExtension) | Assimp::Importer | [inline]
pimpl | Assimp::Importer | [protected]
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 |
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) | Assimp::Importer |
~Importer() | Assimp::Importer |


assimp: Member List

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]
operator delete(void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator delete[](void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator new(size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
operator new[](size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
write(const char *message)=0 | Assimp::LogStream | [pure virtual]
~LogStream() | Assimp::LogStream | [inline, virtual]

Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Member List

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 std::string &message) | Assimp::Logger |
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 std::string &message) | Assimp::Logger |
ErrorSeverity enum name | Assimp::Logger |
getLogSeverity() const | Assimp::Logger | [inline]
info(const std::string &message) | Assimp::Logger |
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]
operator delete(void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator delete[](void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator new(size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
operator new[](size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
setLogSeverity(LogSeverity log_severity) | Assimp::Logger | [inline]
VERBOSE enum value | Assimp::Logger |
warn(const std::string &message) | Assimp::Logger |
WARN enum value | Assimp::Logger |
~Logger() | Assimp::Logger | [inline, virtual]


assimp: Member List

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 std::string &message) | Assimp::Logger |
DEBUGGING enum value | Assimp::Logger |
detatchStream(LogStream *pStream, unsigned int severity) | Assimp::NullLogger | [inline, virtual]
ERR enum value | Assimp::Logger |
error(const std::string &message) | Assimp::Logger |
ErrorSeverity enum name | Assimp::Logger |
getLogSeverity() const | Assimp::Logger | [inline]
info(const std::string &message) | Assimp::Logger |
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]
operator delete(void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator delete[](void *data) | Assimp::Intern::AllocateFromAssimpHeap |
operator new(size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
operator new[](size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap |
setLogSeverity(LogSeverity log_severity) | Assimp::Logger | [inline]
VERBOSE enum value | Assimp::Logger |
WARN enum value | Assimp::Logger |
warn(const std::string &message) | Assimp::Logger |
~Logger() | Assimp::Logger | [inline, virtual]

Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Alphabetical List

Class Index

A | D | I | L | N

A
aiLight aiQuaternion aiVector3D Interpolator (Assimp)
aiAnimation aiLogStream aiQuatKey aiVectorKey IOStream (Assimp)
aiBone aiMaterial aiRay aiVertexWeight IOSystem (Assimp)
aiCamera aiMatrix3x3 aiScene AllocateFromAssimpHeap (Assimp::Intern)
L
aiColor3D aiMatrix4x4 aiString
D
Logger (Assimp)
aiColor4D aiMesh aiTexel DefaultLogger (Assimp) LogStream (Assimp)
aiFace aiNode aiTexture
I
N
aiFile aiNodeAnim aiUVTransform Importer (Assimp) NullLogger (Assimp)
aiFileIO aiPlane aiVector2D

A | D | I | L | N


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() : aiVector2D , aiVector3D
  • length : aiString
  • 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
  • mAspect : aiCamera
  • mAttenuationConstant : aiLight
  • mAttenuationLinear : aiLight
  • mAttenuationQuadratic : aiLight
  • mBitangents : aiMesh
  • mBones : aiMesh
  • mCameras : aiScene
  • mChannels : aiAnimation
  • mChildren : aiNode
  • mClipPlaneFar : aiCamera
  • mClipPlaneNear : aiCamera
  • mColorAmbient : aiLight
  • mColorDiffuse : aiLight
  • mColors : aiMesh
  • mColorSpecular : aiLight
  • mDirection : aiLight
  • mDuration : aiAnimation
  • mFaces : aiMesh
  • mFlags : aiScene
  • mHeight : aiTexture
  • mHorizontalFOV : aiCamera
  • mIndices : aiFace
  • mLights : aiScene
  • mLookAt : aiCamera
  • mMaterialIndex : aiMesh
  • mMaterials : aiScene
  • mMeshes : aiScene , aiNode
  • mName : aiAnimation , aiCamera , aiLight , aiBone , aiNode
  • mNodeName : aiNodeAnim
  • mNormals : aiMesh
  • mNumAllocated : aiMaterial
  • mNumAnimations : aiScene
  • mNumBones : aiMesh
  • mNumCameras : aiScene
  • mNumChannels : aiAnimation
  • mNumChildren : aiNode
  • mNumFaces : aiMesh
  • mNumIndices : aiFace
  • mNumLights : aiScene
  • mNumMaterials : aiScene
  • mNumMeshes : aiNode , aiScene
  • mNumPositionKeys : aiNodeAnim
  • mNumProperties : aiMaterial
  • mNumRotationKeys : aiNodeAnim
  • mNumScalingKeys : aiNodeAnim
  • mNumTextures : aiScene
  • mNumUVComponents : aiMesh
  • mNumVertices : aiMesh
  • mNumWeights : aiBone
  • mOffsetMatrix : aiBone
  • mParent : aiNode
  • mPosition : aiLight , aiCamera
  • mPositionKeys : aiNodeAnim
  • mPostState : aiNodeAnim
  • mPreState : aiNodeAnim
  • mPrimitiveTypes : aiMesh
  • mProperties : aiMaterial
  • mRootNode : aiScene
  • mRotation : aiUVTransform
  • mRotationKeys : aiNodeAnim
  • mScaling : aiUVTransform
  • mScalingKeys : aiNodeAnim
  • mTangents : aiMesh
  • mTextureCoords : aiMesh
  • mTextures : aiScene
  • mTicksPerSecond : aiAnimation
  • mTime : aiQuatKey , aiVectorKey
  • mTransformation : aiNode
  • mTranslation : aiUVTransform
  • mType : aiLight
  • mUp : aiCamera
  • mValue : aiQuatKey , aiVectorKey
  • mVertexId : aiVertexWeight
  • mVertices : 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 -

  • NORMAL : Assimp::Logger
  • Normalize() : aiVector3D , aiVector2D , aiQuaternion


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 delete() : Assimp::Intern::AllocateFromAssimpHeap
  • operator delete[]() : Assimp::Intern::AllocateFromAssimpHeap
  • operator new() : Assimp::Intern::AllocateFromAssimpHeap
  • operator new[]() : Assimp::Intern::AllocateFromAssimpHeap
  • operator!=() : aiVectorKey , aiQuatKey , aiMatrix3x3 , aiMatrix4x4 , aiFace , aiQuaternion , aiTexel , aiColor3D , aiColor4D , aiString , aiVector2D , aiVector3D
  • operator()() : Assimp::Interpolator< T >
  • operator*() : aiQuaternion , aiColor3D , aiMatrix3x3 , aiMatrix4x4
  • operator*=() : aiMatrix3x3 , aiMatrix4x4 , aiVector2D , aiVector3D
  • operator+() : aiColor3D
  • operator+=() : aiVector3D , aiVector2D
  • operator-() : aiColor3D
  • operator-=() : aiVector2D , aiVector3D
  • operator/=() : aiVector2D , aiVector3D
  • operator<() : aiVectorKey , aiQuatKey
  • operator=() : aiFace , aiString , aiVector2D
  • operator==() : aiString , aiVector3D , aiFace , aiVector2D , aiTexel , aiColor4D , aiColor3D , aiMatrix4x4 , aiQuaternion , aiVectorKey , aiQuatKey , aiMatrix3x3
  • operator>() : aiVectorKey , aiQuatKey
  • operator[]() : aiColor4D , aiMatrix3x3 , aiMatrix4x4 , aiMatrix3x3 , aiVector2D , aiVector3D , aiColor4D , aiColor3D , aiVector3D , aiMatrix4x4 , aiVector2D , aiColor3D


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 : aiQuaternion , aiVector3D


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
  • ~aiBone() : aiBone
  • ~aiFace() : aiFace
  • ~aiMaterial() : aiMaterial
  • ~aiMesh() : aiMesh
  • ~aiNode() : aiNode
  • ~aiNodeAnim() : aiNodeAnim
  • ~aiScene() : aiScene
  • ~aiTexture() : aiTexture
  • ~Importer() : Assimp::Importer
  • ~IOStream() : Assimp::IOStream
  • ~IOSystem() : Assimp::IOSystem
  • ~Logger() : 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:

- b -

  • b : aiTexel , aiPlane , aiColor4D , aiColor3D
  • b1 : aiMatrix3x3 , aiMatrix4x4
  • b2 : aiMatrix4x4 , aiMatrix3x3
  • b3 : aiMatrix3x3 , aiMatrix4x4
  • b4 : aiMatrix4x4
  • BaseProcess : Assimp::Importer
  • BatchLoader : Assimp::Importer


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 : aiMatrix3x3 , aiMatrix4x4
  • c2 : aiMatrix3x3 , aiMatrix4x4
  • c3 : aiMatrix3x3 , aiMatrix4x4
  • c4 : aiMatrix4x4
  • callback : aiLogStream
  • CheckFormat() : aiTexture
  • Clear() : aiString
  • Close() : Assimp::IOSystem
  • CloseProc : aiFileIO
  • ComparePaths() : Assimp::IOSystem
  • Conjugate() : aiQuaternion
  • 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 : aiMatrix4x4
  • d2 : aiMatrix4x4
  • d3 : aiMatrix4x4
  • d4 : aiMatrix4x4
  • data : aiString
  • debug() : Assimp::Logger
  • DEBUGGING : Assimp::Logger
  • Decompose() : aiMatrix4x4
  • DecomposeNoScaling() : aiMatrix4x4
  • detatchStream()
: Assimp::NullLogger
, Assimp::Logger
, Assimp::DefaultLogger
  • Determinant() : aiMatrix4x4 , aiMatrix3x3
  • dir : aiRay


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
  • ERR : Assimp::Logger
  • error() : Assimp::Logger
  • ErrorSeverity : Assimp::Logger
  • Exists() : Assimp::IOSystem


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 -

  • FileSize() : Assimp::IOStream
  • FileSizeProc : aiFile
  • FindLoader() : Assimp::Importer
  • FindNode() : aiNode
  • Flush() : Assimp::IOStream
  • FlushProc : aiFile
  • FreeScene() : Assimp::Importer
  • FromEulerAnglesXYZ() : aiMatrix4x4
  • FromToMatrix() : aiMatrix4x4 , aiMatrix3x3


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 : aiTexel , aiColor3D , aiColor4D
  • get() : Assimp::DefaultLogger
  • Get() : aiMaterial
  • GetCameraMatrix() : aiCamera
  • GetErrorString() : Assimp::Importer
  • GetExtensionList() : Assimp::Importer
  • GetIOHandler() : Assimp::Importer
  • getLogSeverity() : Assimp::Logger
  • GetMatrix() : aiQuaternion
  • GetMemoryRequirements() : Assimp::Importer
  • GetNumColorChannels() : aiMesh
  • GetNumUVChannels() : aiMesh
  • GetOrphanedScene() : Assimp::Importer
  • getOsSeparator() : Assimp::IOSystem
  • GetPropertyFloat() : Assimp::Importer
  • GetPropertyInteger() : Assimp::Importer
  • GetPropertyString() : Assimp::Importer
  • GetScene() : Assimp::Importer
  • GetTexture() : 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() : aiMesh
  • HasPositions() : aiMesh
  • HasTangentsAndBitangents() : aiMesh
  • HasTextureCoords() : aiMesh
  • HasTextures() : aiScene
  • HasVertexColors() : aiMesh


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 -

  • Importer() : Assimp::Importer
  • info() : Assimp::Logger
  • INFO : Assimp::Logger
  • Interpolate() : aiQuaternion
  • Inverse() : aiMatrix3x3 , aiMatrix4x4
  • IOStream() : Assimp::IOStream
  • IOSystem() : Assimp::IOSystem
  • IsBlack() : aiColor3D , aiColor4D
  • IsDefaultIOHandler() : Assimp::Importer
  • IsExtensionSupported() : Assimp::Importer
  • IsIdentity() : aiMatrix4x4
  • 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::Importer
  • pos : aiRay


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 : aiTexel , aiColor3D , aiColor4D
  • Read() : Assimp::IOStream
  • ReadFile() : Assimp::Importer
  • ReadFileFromMemory() : Assimp::Importer
  • ReadProc : aiFile
  • RegisterLoader() : Assimp::Importer
  • RegisterPPStep() : Assimp::Importer
  • Rotate() : aiQuaternion
  • Rotation() : aiMatrix4x4 , aiMatrix3x3
  • RotationX() : aiMatrix4x4
  • RotationY() : aiMatrix4x4
  • RotationZ() : aiMatrix3x3 , aiMatrix4x4


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() : aiMatrix4x4
  • Seek() : Assimp::IOStream
  • SeekProc : aiFile
  • Set() : aiString
  • set() : Assimp::DefaultLogger
  • Set() : aiString , aiVector2D , aiVector3D
  • SetExtraVerbose() : Assimp::Importer
  • SetIOHandler() : Assimp::Importer
  • setLogSeverity() : Assimp::Logger
  • SetPropertyFloat() : Assimp::Importer
  • SetPropertyInteger() : Assimp::Importer
  • SetPropertyString() : Assimp::Importer
  • SquareLength() : aiVector2D , aiVector3D
  • SymMul() : aiVector3D , aiVector2D


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
  • Translation() : aiMatrix4x4 , aiMatrix3x3
  • Transpose() : aiMatrix4x4 , aiMatrix3x3


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 -

  • UnregisterLoader() : Assimp::Importer
  • UnregisterPPStep() : Assimp::Importer
  • 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 : aiQuaternion
  • 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 : aiQuaternion , aiVector3D , aiVector2D


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 : aiQuaternion , aiVector3D , aiVector2D


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
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- a -

  • aiAnimation() : aiAnimation
  • aiBone() : aiBone
  • aiCamera() : aiCamera
  • aiColor3D() : aiColor3D
  • aiColor4D() : aiColor4D
  • aiFace() : aiFace
  • aiLight() : aiLight
  • aiMaterial() : aiMaterial
  • aiMatrix3x3() : aiMatrix3x3
  • aiMatrix4x4() : aiMatrix4x4
  • aiMesh() : aiMesh
  • aiNode() : aiNode
  • aiNodeAnim() : aiNodeAnim
  • aiPlane() : aiPlane
  • aiQuaternion() : aiQuaternion
  • aiQuatKey() : aiQuatKey
  • aiRay() : aiRay
  • aiScene() : aiScene
  • aiString() : aiString
  • aiTexture() : aiTexture
  • aiUVTransform() : aiUVTransform
  • aiVector2D() : aiVector2D
  • aiVector3D() : aiVector3D
  • aiVectorKey() : aiVectorKey
  • aiVertexWeight() : aiVertexWeight
  • Append() : aiString
  • ApplyPostProcessing() : Assimp::Importer
  • attachStream()
: Assimp::NullLogger
, Assimp::DefaultLogger
, Assimp::Logger


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- k -

  • kill() : Assimp::DefaultLogger


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- l -

  • Length() : aiVector2D , aiVector3D
  • Logger() : Assimp::Logger
  • LogStream() : Assimp::LogStream


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- n -

  • Normalize() : aiQuaternion , aiVector3D , aiVector2D


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • 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 delete() : Assimp::Intern::AllocateFromAssimpHeap
  • operator delete[]() : Assimp::Intern::AllocateFromAssimpHeap
  • operator new() : Assimp::Intern::AllocateFromAssimpHeap
  • operator new[]() : Assimp::Intern::AllocateFromAssimpHeap
  • operator!=() : aiVectorKey , aiQuatKey , aiMatrix3x3 , aiMatrix4x4 , aiFace , aiQuaternion , aiTexel , aiColor3D , aiColor4D , aiString , aiVector2D , aiVector3D
  • operator()() : Assimp::Interpolator< T >
  • operator*() : aiColor3D , aiMatrix3x3 , aiMatrix4x4 , aiQuaternion
  • operator*=() : aiMatrix3x3 , aiMatrix4x4 , aiVector2D , aiVector3D
  • operator+() : aiColor3D
  • operator+=() : aiVector2D , aiVector3D
  • operator-() : aiColor3D
  • operator-=() : aiVector2D , aiVector3D
  • operator/=() : aiVector3D , aiVector2D
  • operator<() : aiVectorKey , aiQuatKey
  • operator=() : aiString , aiFace , aiString , aiVector2D
  • operator==() : aiString , aiVector2D , aiColor3D , aiVector3D , aiColor4D , aiQuaternion , aiFace , aiQuatKey , aiMatrix4x4 , aiVectorKey , aiMatrix3x3 , aiTexel
  • operator>() : aiVectorKey , aiQuatKey
  • operator[]() : aiMatrix4x4 , aiVector3D , aiColor4D , aiVector2D , aiVector3D , aiVector2D , aiColor3D , aiMatrix3x3 , aiColor3D , aiColor4D , aiMatrix3x3


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- ~ -

  • ~aiAnimation() : aiAnimation
  • ~aiBone() : aiBone
  • ~aiFace() : aiFace
  • ~aiMaterial() : aiMaterial
  • ~aiMesh() : aiMesh
  • ~aiNode() : aiNode
  • ~aiNodeAnim() : aiNodeAnim
  • ~aiScene() : aiScene
  • ~aiTexture() : aiTexture
  • ~Importer() : Assimp::Importer
  • ~IOStream() : Assimp::IOStream
  • ~IOSystem() : Assimp::IOSystem
  • ~Logger() : Assimp::Logger
  • ~LogStream() : Assimp::LogStream


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- c -

  • CheckFormat() : aiTexture
  • Clear() : aiString
  • Close() : Assimp::IOSystem
  • ComparePaths() : Assimp::IOSystem
  • Conjugate() : aiQuaternion
  • create() : Assimp::DefaultLogger
  • createDefaultStream() : Assimp::LogStream


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- d -

  • debug() : Assimp::Logger
  • Decompose() : aiMatrix4x4
  • DecomposeNoScaling() : aiMatrix4x4
  • detatchStream()
: Assimp::DefaultLogger
, Assimp::Logger
, Assimp::NullLogger
  • Determinant() : aiMatrix4x4 , aiMatrix3x3


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- e -

  • error() : Assimp::Logger
  • Exists() : Assimp::IOSystem


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- f -

  • FileSize() : Assimp::IOStream
  • FindLoader() : Assimp::Importer
  • FindNode() : aiNode
  • Flush() : Assimp::IOStream
  • FreeScene() : Assimp::Importer
  • FromEulerAnglesXYZ() : aiMatrix4x4
  • FromToMatrix() : aiMatrix4x4 , aiMatrix3x3


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- g -

  • get() : Assimp::DefaultLogger
  • Get() : aiMaterial
  • GetCameraMatrix() : aiCamera
  • GetErrorString() : Assimp::Importer
  • GetExtensionList() : Assimp::Importer
  • GetIOHandler() : Assimp::Importer
  • getLogSeverity() : Assimp::Logger
  • GetMatrix() : aiQuaternion
  • GetMemoryRequirements() : Assimp::Importer
  • GetNumColorChannels() : aiMesh
  • GetNumUVChannels() : aiMesh
  • GetOrphanedScene() : Assimp::Importer
  • getOsSeparator() : Assimp::IOSystem
  • GetPropertyFloat() : Assimp::Importer
  • GetPropertyInteger() : Assimp::Importer
  • GetPropertyString() : Assimp::Importer
  • GetScene() : Assimp::Importer
  • GetTexture() : aiMaterial


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- h -

  • HasAnimations() : aiScene
  • HasBones() : aiMesh
  • HasCameras() : aiScene
  • HasFaces() : aiMesh
  • HasLights() : aiScene
  • HasMaterials() : aiScene
  • HasMeshes() : aiScene
  • HasNormals() : aiMesh
  • HasPositions() : aiMesh
  • HasTangentsAndBitangents() : aiMesh
  • HasTextureCoords() : aiMesh
  • HasTextures() : aiScene
  • HasVertexColors() : aiMesh


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- i -

  • Importer() : Assimp::Importer
  • info() : Assimp::Logger
  • Interpolate() : aiQuaternion
  • Inverse() : aiMatrix3x3 , aiMatrix4x4
  • IOStream() : Assimp::IOStream
  • IOSystem() : Assimp::IOSystem
  • IsBlack() : aiColor3D , aiColor4D
  • IsDefaultIOHandler() : Assimp::Importer
  • IsExtensionSupported() : Assimp::Importer
  • IsIdentity() : aiMatrix4x4
  • isNullLogger() : Assimp::DefaultLogger


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- r -

  • Read() : Assimp::IOStream
  • ReadFile() : Assimp::Importer
  • ReadFileFromMemory() : Assimp::Importer
  • RegisterLoader() : Assimp::Importer
  • RegisterPPStep() : Assimp::Importer
  • Rotate() : aiQuaternion
  • Rotation() : aiMatrix3x3 , aiMatrix4x4
  • RotationX() : aiMatrix4x4
  • RotationY() : aiMatrix4x4
  • RotationZ() : aiMatrix4x4 , aiMatrix3x3


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- s -

  • Scaling() : aiMatrix4x4
  • Seek() : Assimp::IOStream
  • Set() : aiString , aiVector2D , aiString , aiVector3D
  • set() : Assimp::DefaultLogger
  • SetExtraVerbose() : Assimp::Importer
  • SetIOHandler() : Assimp::Importer
  • setLogSeverity() : Assimp::Logger
  • SetPropertyFloat() : Assimp::Importer
  • SetPropertyInteger() : Assimp::Importer
  • SetPropertyString() : Assimp::Importer
  • SquareLength() : aiVector3D , aiVector2D
  • SymMul() : aiVector3D , aiVector2D


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- t -

  • Tell() : Assimp::IOStream
  • Translation() : aiMatrix3x3 , aiMatrix4x4
  • Transpose() : aiMatrix3x3 , aiMatrix4x4


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- u -

  • UnregisterLoader() : Assimp::Importer
  • UnregisterPPStep() : Assimp::Importer


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- v -

  • ValidateFlags() : Assimp::Importer


assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • 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

  • aiImportFileEx : Assimp::Importer
  • aiImportFileFromMemory : Assimp::Importer
  • BaseProcess : Assimp::Importer
  • BatchLoader : Assimp::Importer


assimp: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions

  • elem_type : aiVectorKey , aiQuatKey


assimp: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • g
  • l
  • m
  • o
  • p
  • r
  • s
  • t
  • u
  • w
  • x
  • y
  • z

- a -

  • a : aiTexel , aiPlane , aiColor4D
  • a1 : aiMatrix3x3 , aiMatrix4x4
  • a2 : aiMatrix4x4 , aiMatrix3x3
  • a3 : aiMatrix4x4 , aiMatrix3x3
  • a4 : aiMatrix4x4
  • achFormatHint : aiTexture

- b -

  • b : aiTexel , aiPlane , aiColor4D , aiColor3D
  • b1 : aiMatrix3x3 , aiMatrix4x4
  • b2 : aiMatrix4x4 , aiMatrix3x3
  • b3 : aiMatrix3x3 , aiMatrix4x4
  • b4 : aiMatrix4x4

- c -

  • c : aiPlane
  • c1 : aiMatrix3x3 , aiMatrix4x4
  • c2 : aiMatrix3x3 , aiMatrix4x4
  • c3 : aiMatrix4x4 , aiMatrix3x3
  • c4 : aiMatrix4x4
  • callback : aiLogStream
  • CloseProc : aiFileIO

- d -

  • d : aiPlane
  • d1 : aiMatrix4x4
  • d2 : aiMatrix4x4
  • d3 : aiMatrix4x4
  • d4 : aiMatrix4x4
  • data : aiString
  • dir : aiRay

- f -

  • FileSizeProc : aiFile
  • FlushProc : aiFile

- g -

  • g : aiTexel , aiColor4D , aiColor3D

- l -

  • length : aiString

- m -

  • m_Severity : Assimp::Logger
  • mAngleInnerCone : aiLight
  • mAngleOuterCone : aiLight
  • mAnimations : aiScene
  • mAspect : aiCamera
  • mAttenuationConstant : aiLight
  • mAttenuationLinear : aiLight
  • mAttenuationQuadratic : aiLight
  • mBitangents : aiMesh
  • mBones : aiMesh
  • mCameras : aiScene
  • mChannels : aiAnimation
  • mChildren : aiNode
  • mClipPlaneFar : aiCamera
  • mClipPlaneNear : aiCamera
  • mColorAmbient : aiLight
  • mColorDiffuse : aiLight
  • mColors : aiMesh
  • mColorSpecular : aiLight
  • mDirection : aiLight
  • mDuration : aiAnimation
  • mFaces : aiMesh
  • mFlags : aiScene
  • mHeight : aiTexture
  • mHorizontalFOV : aiCamera
  • mIndices : aiFace
  • mLights : aiScene
  • mLookAt : aiCamera
  • mMaterialIndex : aiMesh
  • mMaterials : aiScene
  • mMeshes : aiScene , aiNode
  • mName : aiAnimation , aiCamera , aiLight , aiBone , aiNode
  • mNodeName : aiNodeAnim
  • mNormals : aiMesh
  • mNumAllocated : aiMaterial
  • mNumAnimations : aiScene
  • mNumBones : aiMesh
  • mNumCameras : aiScene
  • mNumChannels : aiAnimation
  • mNumChildren : aiNode
  • mNumFaces : aiMesh
  • mNumIndices : aiFace
  • mNumLights : aiScene
  • mNumMaterials : aiScene
  • mNumMeshes : aiNode , aiScene
  • mNumPositionKeys : aiNodeAnim
  • mNumProperties : aiMaterial
  • mNumRotationKeys : aiNodeAnim
  • mNumScalingKeys : aiNodeAnim
  • mNumTextures : aiScene
  • mNumUVComponents : aiMesh
  • mNumVertices : aiMesh
  • mNumWeights : aiBone
  • mOffsetMatrix : aiBone
  • mParent : aiNode
  • mPosition : aiLight , aiCamera
  • mPositionKeys : aiNodeAnim
  • mPostState : aiNodeAnim
  • mPreState : aiNodeAnim
  • mPrimitiveTypes : aiMesh
  • mProperties : aiMaterial
  • mRootNode : aiScene
  • mRotation : aiUVTransform
  • mRotationKeys : aiNodeAnim
  • mScaling : aiUVTransform
  • mScalingKeys : aiNodeAnim
  • mTangents : aiMesh
  • mTextureCoords : aiMesh
  • mTextures : aiScene
  • mTicksPerSecond : aiAnimation
  • mTime : aiQuatKey , aiVectorKey
  • mTransformation : aiNode
  • mTranslation : aiUVTransform
  • mType : aiLight
  • mUp : aiCamera
  • mValue : aiQuatKey , aiVectorKey
  • mVertexId : aiVertexWeight
  • mVertices : aiMesh
  • mWeight : aiVertexWeight
  • mWeights : aiBone
  • mWidth : aiTexture

- o -

  • OpenProc : aiFileIO

- p -

  • pcData : aiTexture
  • pimpl : Assimp::Importer
  • pos : aiRay

- r -

  • r : aiTexel , aiColor3D , aiColor4D
  • ReadProc : aiFile

- s -

  • SeekProc : aiFile

- t -

  • TellProc : aiFile

- u -

  • user : aiLogStream
  • UserData : aiFile , aiFileIO

- w -

  • w : aiQuaternion
  • WriteProc : aiFile

- x -

  • x : aiQuaternion , aiVector3D , aiVector2D

- y -

  • y : aiQuaternion , aiVector3D , aiVector2D

- z -

  • z : aiQuaternion , aiVector3D


assimp: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator

  • aiAnimBehaviour : aiAnim.h
  • aiBlendMode : aiMaterial.h
  • aiComponent : aiConfig.h
  • aiLightSourceType : aiLight.h
  • aiPostProcessSteps : aiPostProcess.h
  • aiPrimitiveType : aiMesh.h
  • aiShadingMode : aiMaterial.h
  • aiTextureFlags : aiMaterial.h
  • aiTextureMapMode : aiMaterial.h
  • aiTextureMapping : aiMaterial.h
  • aiTextureOp : aiMaterial.h
  • aiTextureType : aiMaterial.h
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a

- _ -

  • _aiAnimBehaviour_Force32Bit : aiAnim.h
  • _aiComponent_Force32Bit : aiConfig.h
  • _aiLightSource_Force32Bit : aiLight.h
  • _aiPrimitiveType_Force32Bit : aiMesh.h

- a -

  • aiAnimBehaviour_CONSTANT : aiAnim.h
  • aiAnimBehaviour_DEFAULT : aiAnim.h
  • aiAnimBehaviour_LINEAR : aiAnim.h
  • aiAnimBehaviour_REPEAT : aiAnim.h
  • aiBlendMode_Additive : aiMaterial.h
  • aiBlendMode_Default : aiMaterial.h
  • aiComponent_ANIMATIONS : aiConfig.h
  • aiComponent_BONEWEIGHTS : aiConfig.h
  • aiComponent_CAMERAS : aiConfig.h
  • aiComponent_COLORS : aiConfig.h
  • aiComponent_LIGHTS : aiConfig.h
  • aiComponent_MATERIALS : aiConfig.h
  • aiComponent_MESHES : aiConfig.h
  • aiComponent_NORMALS : aiConfig.h
  • aiComponent_TANGENTS_AND_BITANGENTS : aiConfig.h
  • aiComponent_TEXCOORDS : aiConfig.h
  • aiComponent_TEXTURES : aiConfig.h
  • aiLightSource_DIRECTIONAL : aiLight.h
  • aiLightSource_POINT : aiLight.h
  • aiLightSource_SPOT : aiLight.h
  • aiLightSource_UNDEFINED : aiLight.h
  • aiPrimitiveType_LINE : aiMesh.h
  • aiPrimitiveType_POINT : aiMesh.h
  • aiPrimitiveType_POLYGON : aiMesh.h
  • aiPrimitiveType_TRIANGLE : aiMesh.h
  • aiProcess_CalcTangentSpace : aiPostProcess.h
  • aiProcess_FindDegenerates : aiPostProcess.h
  • aiProcess_FindInstances : aiPostProcess.h
  • aiProcess_FindInvalidData : aiPostProcess.h
  • aiProcess_FixInfacingNormals : aiPostProcess.h
  • aiProcess_FlipUVs : aiPostProcess.h
  • aiProcess_FlipWindingOrder : aiPostProcess.h
  • aiProcess_GenNormals : aiPostProcess.h
  • aiProcess_GenSmoothNormals : aiPostProcess.h
  • aiProcess_GenUVCoords : aiPostProcess.h
  • aiProcess_ImproveCacheLocality : aiPostProcess.h
  • aiProcess_JoinIdenticalVertices : aiPostProcess.h
  • aiProcess_LimitBoneWeights : aiPostProcess.h
  • aiProcess_MakeLeftHanded : aiPostProcess.h
  • aiProcess_OptimizeGraph : aiPostProcess.h
  • aiProcess_OptimizeMeshes : aiPostProcess.h
  • aiProcess_PreTransformVertices : aiPostProcess.h
  • aiProcess_RemoveComponent : aiPostProcess.h
  • aiProcess_RemoveRedundantMaterials : aiPostProcess.h
  • aiProcess_SortByPType : aiPostProcess.h
  • aiProcess_SplitLargeMeshes : aiPostProcess.h
  • aiProcess_TransformUVCoords : aiPostProcess.h
  • aiProcess_Triangulate : aiPostProcess.h
  • aiProcess_ValidateDataStructure : aiPostProcess.h
  • aiShadingMode_Blinn : aiMaterial.h
  • aiShadingMode_CookTorrance : aiMaterial.h
  • aiShadingMode_Flat : aiMaterial.h
  • aiShadingMode_Fresnel : aiMaterial.h
  • aiShadingMode_Gouraud : aiMaterial.h
  • aiShadingMode_Minnaert : aiMaterial.h
  • aiShadingMode_NoShading : aiMaterial.h
  • aiShadingMode_OrenNayar : aiMaterial.h
  • aiShadingMode_Phong : aiMaterial.h
  • aiShadingMode_Toon : aiMaterial.h
  • aiTextureFlags_IgnoreAlpha : aiMaterial.h
  • aiTextureFlags_Invert : aiMaterial.h
  • aiTextureFlags_UseAlpha : aiMaterial.h
  • aiTextureMapMode_Clamp : aiMaterial.h
  • aiTextureMapMode_Decal : aiMaterial.h
  • aiTextureMapMode_Mirror : aiMaterial.h
  • aiTextureMapMode_Wrap : aiMaterial.h
  • aiTextureMapping_BOX : aiMaterial.h
  • aiTextureMapping_CYLINDER : aiMaterial.h
  • aiTextureMapping_OTHER : aiMaterial.h
  • aiTextureMapping_PLANE : aiMaterial.h
  • aiTextureMapping_SPHERE : aiMaterial.h
  • aiTextureMapping_UV : aiMaterial.h
  • aiTextureOp_Add : aiMaterial.h
  • aiTextureOp_Divide : aiMaterial.h
  • aiTextureOp_Multiply : aiMaterial.h
  • aiTextureOp_SignedAdd : aiMaterial.h
  • aiTextureOp_SmoothAdd : aiMaterial.h
  • aiTextureOp_Subtract : aiMaterial.h
  • aiTextureType_AMBIENT : aiMaterial.h
  • aiTextureType_DIFFUSE : aiMaterial.h
  • aiTextureType_DISPLACEMENT : aiMaterial.h
  • aiTextureType_EMISSIVE : aiMaterial.h
  • aiTextureType_HEIGHT : aiMaterial.h
  • aiTextureType_LIGHTMAP : aiMaterial.h
  • aiTextureType_NONE : aiMaterial.h
  • aiTextureType_NORMALS : aiMaterial.h
  • aiTextureType_OPACITY : aiMaterial.h
  • aiTextureType_REFLECTION : aiMaterial.h
  • aiTextureType_SHININESS : aiMaterial.h
  • aiTextureType_SPECULAR : aiMaterial.h
  • aiTextureType_UNKNOWN : aiMaterial.h
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • o

- a -

  • aiApplyPostProcessing() : assimp.h
  • aiAttachLogStream() : assimp.h
  • aiCreateQuaternionFromMatrix() : assimp.h
  • aiDecomposeMatrix() : assimp.h
  • aiDetachAllLogStreams() : assimp.h
  • aiDetachLogStream() : assimp.h
  • aiEnableVerboseLogging() : assimp.h
  • aiGetCompileFlags() : aiVersion.h
  • aiGetErrorString() : assimp.h
  • aiGetExtensionList() : assimp.h
  • aiGetLegalString() : aiVersion.h
  • aiGetMemoryRequirements() : assimp.h
  • aiGetPredefinedLogStream() : assimp.h
  • aiGetVersionMajor() : aiVersion.h
  • aiGetVersionMinor() : aiVersion.h
  • aiGetVersionRevision() : aiVersion.h
  • aiIdentityMatrix3() : assimp.h
  • aiIdentityMatrix4() : assimp.h
  • aiImportFile() : assimp.h
  • aiImportFileEx() : assimp.h , assimp.hpp
  • aiImportFileFromMemory() : assimp.h , assimp.hpp
  • aiIsExtensionSupported() : assimp.h
  • aiMultiplyMatrix3() : assimp.h
  • aiMultiplyMatrix4() : assimp.h
  • aiReleaseImport() : assimp.h
  • aiSetImportPropertyFloat() : assimp.h
  • aiSetImportPropertyInteger() : assimp.h
  • aiSetImportPropertyString() : assimp.h
  • aiTransformVecByMatrix3() : assimp.h
  • aiTransformVecByMatrix4() : assimp.h
  • aiTransposeMatrix3() : assimp.h
  • aiTransposeMatrix4() : assimp.h

- o -

  • operator*() : aiVector2D.h , aiVector3D.inl , aiVector2D.h , aiVector3D.inl
  • operator+() : aiVector2D.h , aiVector3D.inl
  • operator-() : aiVector2D.h , aiVector3D.inl , aiVector2D.h , aiVector3D.inl
  • operator/() : aiVector3D.inl , aiVector2D.h , aiVector3D.inl
  • operator^() : aiVector3D.inl
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator

  • aiBool : assimp.h
  • aiFileCloseProc : aiFileIO.h
  • aiFileFlushProc : aiFileIO.h
  • aiFileOpenProc : aiFileIO.h
  • aiFileReadProc : aiFileIO.h
  • aiFileSeek : aiFileIO.h
  • aiFileTellProc : aiFileIO.h
  • aiFileWriteProc : aiFileIO.h
  • aiLogStreamCallback : assimp.h
  • aiUserData : aiFileIO.h
  • int_fast16_t : pstdint.h
  • int_fast32_t : pstdint.h
  • int_fast8_t : pstdint.h
  • int_least16_t : pstdint.h
  • int_least32_t : pstdint.h
  • int_least8_t : pstdint.h
  • intmax_t : pstdint.h
  • intptr_t : pstdint.h
  • uint_fast16_t : pstdint.h
  • uint_fast32_t : pstdint.h
  • uint_fast8_t : pstdint.h
  • uint_least16_t : pstdint.h
  • uint_least32_t : pstdint.h
  • uint_least8_t : pstdint.h
  • uintmax_t : pstdint.h
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator

  • MAXLEN : aiTypes.h
  • PACK_STRUCT : aiMaterial.h , aiVector3D.h , aiVector2D.h , aiTypes.h , aiTexture.h , aiMatrix4x4.h
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions

  • aiAssert() : Assimp
Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Page Index

Related Pages

Here is a list of all related documentation pages:
  • Installation
  • Usage
  • Data Structures
  • Material System
  • The Viewer
Generated on Sun Jul 19 17:01:48 2009 for assimp by doxygen 1.5.8


assimp: Member List

Assimp::Intern::AllocateFromAssimpHeap Member List

This is the complete list of members for Assimp::Intern::AllocateFromAssimpHeap, including all inherited members.

operator delete(void *data) | Assimp::Intern::AllocateFromAssimpHeap
operator delete[](void *data) | Assimp::Intern::AllocateFromAssimpHeap
operator new(size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap
operator new[](size_t num_bytes) | Assimp::Intern::AllocateFromAssimpHeap

Generated on Sun Jul 19 17:01:50 2009 for assimp by doxygen 1.5.8


assimp: Member List

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

aiAnimation Member List

This is the complete list of members for aiAnimation, including all inherited members.

aiAnimation() | aiAnimation | [inline]
mChannels | aiAnimation |
mDuration | aiAnimation |
mName | aiAnimation |
mNumChannels | 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(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

aiColor4D Member List

This is the complete list of members for aiColor4D, including all inherited members.

a | aiColor4D |
aiColor4D() | aiColor4D | [inline]
aiColor4D(float _r, float _g, float _b, float _a) | aiColor4D | [inline]
aiColor4D(const aiColor4D &o) | aiColor4D | [inline]
b | aiColor4D |
g | aiColor4D |
IsBlack() const | aiColor4D | [inline]
operator!=(const aiColor4D &other) const | aiColor4D | [inline]
operator==(const aiColor4D &other) const | aiColor4D | [inline]
operator[](unsigned int i) const | aiColor4D | [inline]
operator[](unsigned int i) | aiColor4D | [inline]
r | aiColor4D |


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

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.

aiMaterial() | aiMaterial | [inline]
Get(const char *pKey, unsigned int type, unsigned int idx, Type *pOut, unsigned int *pMax) const | aiMaterial | [inline]
Get(const char *pKey, unsigned int type, unsigned int idx, Type &pOut) const | aiMaterial | [inline]
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 |
mNumAllocated | aiMaterial |
mNumProperties | aiMaterial |
mProperties | aiMaterial |
~aiMaterial() | aiMaterial |


assimp: Member List

aiMatrix3x3 Member List

This is the complete list of members for aiMatrix3x3, including all inherited members.

a1 | aiMatrix3x3 |
a2 | aiMatrix3x3 |
a3 | aiMatrix3x3 |
aiMatrix3x3() | aiMatrix3x3 | [inline]
aiMatrix3x3(float _a1, float _a2, float _a3, float _b1, float _b2, float _b3, float _c1, float _c2, float _c3) | aiMatrix3x3 | [inline]
aiMatrix3x3(const aiMatrix4x4 &pMatrix) | aiMatrix3x3 | [inline, explicit]
b1 | aiMatrix3x3 |
b2 | aiMatrix3x3 |
b3 | aiMatrix3x3 |
c1 | aiMatrix3x3 |
c2 | aiMatrix3x3 |
c3 | aiMatrix3x3 |
Determinant() const | aiMatrix3x3 | [inline]
FromToMatrix(const aiVector3D &from, const aiVector3D &to, aiMatrix3x3 &out) | aiMatrix3x3 | [inline, static]
Inverse() | aiMatrix3x3 | [inline]
operator!=(const aiMatrix4x4 m) const | aiMatrix3x3 | [inline]
operator*(const aiMatrix3x3 &m) const | aiMatrix3x3 | [inline]
operator*=(const aiMatrix3x3 &m) | aiMatrix3x3 | [inline]
operator==(const aiMatrix4x4 m) const | aiMatrix3x3 | [inline]
operator[](unsigned int p_iIndex) | aiMatrix3x3 | [inline]
operator[](unsigned int p_iIndex) const | aiMatrix3x3 | [inline]
Rotation(float a, const aiVector3D &axis, aiMatrix3x3 &out) | aiMatrix3x3 | [inline, static]
RotationZ(float a, aiMatrix3x3 &out) | aiMatrix3x3 | [inline, static]
Translation(const aiVector2D &v, aiMatrix3x3 &out) | aiMatrix3x3 | [inline, static]
Transpose() | aiMatrix3x3 | [inline]


assimp: Member List

aiMatrix4x4 Member List

This is the complete list of members for aiMatrix4x4, including all inherited members.

a1 | aiMatrix4x4 |
a2 | aiMatrix4x4 |
a3 | aiMatrix4x4 |
a4 | aiMatrix4x4 |
aiMatrix4x4() | aiMatrix4x4 | [inline]
aiMatrix4x4(float _a1, float _a2, float _a3, float _a4, float _b1, float _b2, float _b3, float _b4, float _c1, float _c2, float _c3, float _c4, float _d1, float _d2, float _d3, float _d4) | aiMatrix4x4 | [inline]
aiMatrix4x4(const aiMatrix3x3 &m) | aiMatrix4x4 | [inline, explicit]
b1 | aiMatrix4x4 |
b2 | aiMatrix4x4 |
b3 | aiMatrix4x4 |
b4 | aiMatrix4x4 |
c1 | aiMatrix4x4 |
c2 | aiMatrix4x4 |
c3 | aiMatrix4x4 |
c4 | aiMatrix4x4 |
d1 | aiMatrix4x4 |
d2 | aiMatrix4x4 |
d3 | aiMatrix4x4 |
d4 | aiMatrix4x4 |
Decompose(aiVector3D &scaling, aiQuaternion &rotation, aiVector3D &position) const | aiMatrix4x4 | [inline]
DecomposeNoScaling(aiQuaternion &rotation, aiVector3D &position) const | aiMatrix4x4 | [inline]
Determinant() const | aiMatrix4x4 | [inline]
FromEulerAnglesXYZ(float x, float y, float z) | aiMatrix4x4 | [inline]
FromEulerAnglesXYZ(const aiVector3D &blubb) | aiMatrix4x4 | [inline]
FromToMatrix(const aiVector3D &from, const aiVector3D &to, aiMatrix4x4 &out) | aiMatrix4x4 | [inline, static]
Inverse() | aiMatrix4x4 | [inline]
IsIdentity() const | aiMatrix4x4 | [inline]
operator!=(const aiMatrix4x4 m) const | aiMatrix4x4 | [inline]
operator*(const aiMatrix4x4 &m) const | aiMatrix4x4 | [inline]
operator*=(const aiMatrix4x4 &m) | aiMatrix4x4 | [inline]
operator==(const aiMatrix4x4 m) const | aiMatrix4x4 | [inline]
operator[](unsigned int p_iIndex) | aiMatrix4x4 | [inline]
operator[](unsigned int p_iIndex) const | aiMatrix4x4 | [inline]
Rotation(float a, const aiVector3D &axis, aiMatrix4x4 &out) | aiMatrix4x4 | [inline, static]
RotationX(float a, aiMatrix4x4 &out) | aiMatrix4x4 | [inline, static]
RotationY(float a, aiMatrix4x4 &out) | aiMatrix4x4 | [inline, static]
RotationZ(float a, aiMatrix4x4 &out) | aiMatrix4x4 | [inline, static]
Scaling(const aiVector3D &v, aiMatrix4x4 &out) | aiMatrix4x4 | [inline, static]
Translation(const aiVector3D &v, aiMatrix4x4 &out) | aiMatrix4x4 | [inline, static]
Transpose() | aiMatrix4x4 | [inline]


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]
mBitangents | aiMesh |
mBones | aiMesh |
mColors | aiMesh |
mFaces | aiMesh |
mMaterialIndex | aiMesh |
mNormals | aiMesh |
mNumBones | aiMesh |
mNumFaces | aiMesh |
mNumUVComponents | aiMesh |
mNumVertices | aiMesh |
mPrimitiveTypes | aiMesh |
mTangents | aiMesh |
mTextureCoords | aiMesh |
mVertices | aiMesh |
~aiMesh() | aiMesh | [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

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

aiQuaternion Member List

This is the complete list of members for aiQuaternion, including all inherited members.

aiQuaternion() | aiQuaternion | [inline]
aiQuaternion(float _w, float _x, float _y, float _z) | aiQuaternion | [inline]
aiQuaternion(const aiMatrix3x3 &pRotMatrix) | aiQuaternion | [inline]
aiQuaternion(float rotx, float roty, float rotz) | aiQuaternion | [inline]
aiQuaternion(aiVector3D axis, float angle) | aiQuaternion | [inline]
aiQuaternion(aiVector3D normalized) | aiQuaternion | [inline]
Conjugate() | aiQuaternion | [inline]
GetMatrix() const | aiQuaternion | [inline]
Interpolate(aiQuaternion &pOut, const aiQuaternion &pStart, const aiQuaternion &pEnd, float pFactor) | aiQuaternion | [inline, static]
Normalize() | aiQuaternion | [inline]
operator!=(const aiQuaternion &o) const | aiQuaternion | [inline]
operator*(const aiQuaternion &two) const | aiQuaternion | [inline]
operator==(const aiQuaternion &o) const | aiQuaternion | [inline]
Rotate(const aiVector3D &in) | aiQuaternion | [inline]
w | aiQuaternion |
x | aiQuaternion |
y | aiQuaternion |
z | aiQuaternion |


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 | [inline]
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 |
mRootNode | aiScene |
mTextures | aiScene |
~aiScene() | aiScene | [inline]


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]
Append(const char *app) | 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

aiVector2D Member List

This is the complete list of members for aiVector2D, including all inherited members.

aiVector2D() | aiVector2D | [inline]
aiVector2D(float _x, float _y) | aiVector2D | [inline]
aiVector2D(float _xyz) | aiVector2D | [inline]
aiVector2D(const aiVector2D &o) | aiVector2D | [inline]
Length() const | aiVector2D | [inline]
Normalize() | aiVector2D | [inline]
operator!=(const aiVector2D &other) const | aiVector2D | [inline]
operator*=(float f) | aiVector2D | [inline]
operator+=(const aiVector2D &o) | aiVector2D | [inline]
operator-=(const aiVector2D &o) | aiVector2D | [inline]
operator/=(float f) | aiVector2D | [inline]
operator=(float f) | aiVector2D | [inline]
operator==(const aiVector2D &other) const | aiVector2D | [inline]
operator[](unsigned int i) const | aiVector2D | [inline]
operator[](unsigned int i) | aiVector2D | [inline]
Set(float pX, float pY) | aiVector2D | [inline]
SquareLength() const | aiVector2D | [inline]
SymMul(const aiVector2D &o) | aiVector2D | [inline]
x | aiVector2D |
y | aiVector2D |


assimp: Member List

aiVector3D Member List

This is the complete list of members for aiVector3D, including all inherited members.

aiVector3D() | aiVector3D | [inline]
aiVector3D(float _x, float _y, float _z) | aiVector3D | [inline]
aiVector3D(float _xyz) | aiVector3D | [inline]
aiVector3D(const aiVector3D &o) | aiVector3D | [inline]
Length() const | aiVector3D |
Normalize() | aiVector3D |
operator!=(const aiVector3D &other) const | aiVector3D |
operator*=(float f) | aiVector3D |
operator*=(const aiMatrix3x3 &mat) | aiVector3D |
operator*=(const aiMatrix4x4 &mat) | aiVector3D |
operator+=(const aiVector3D &o) | aiVector3D |
operator-=(const aiVector3D &o) | aiVector3D |
operator/=(float f) | aiVector3D |
operator==(const aiVector3D &other) const | aiVector3D |
operator[](unsigned int i) const | aiVector3D |
operator[](unsigned int i) | aiVector3D |
Set(float pX, float pY, float pZ=0.f) | aiVector3D |
SquareLength() const | aiVector3D |
SymMul(const aiVector3D &o) | aiVector3D |
x | aiVector3D |
y | aiVector3D |
z | aiVector3D |


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 |