Imported D bindings into port/dAssimp.

git-svn-id: https://assimp.svn.sourceforge.net/svnroot/assimp/trunk@455 67173fc5-114c-0410-ac8e-9d2fd5bffc1f

port/dAssimp/README

@@ -0,0 +1,11 @@
+D bindings for the Assimp library (http://assimp.sf.net).
+---
+
+These bindings provide access to Assimp's C API. They were directly created
+from the C header files.
+
+You should be able to create sufficient DDoc documentation for the bindings
+using your favourite build tool (such as Rebuild). Please refer to the main
+(Doxygen-generated) documentation for general topics.
+
+Please contact <[email protected]> for any bindings-specific issues.

port/dAssimp/assimp/animation.d

@@ -0,0 +1,236 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * The data structures which are used to store the imported animation data.
+ */
+module assimp.animation;
+
+import assimp.math;
+import assimp.types;
+
+extern ( C ) {
+   /**
+    * A time-value pair specifying a certain 3D vector for the given time.
+    */
+   struct aiVectorKey {
+      /**
+       * The time of this key.
+       */
+      double mTime;
+
+      /**
+       * The value of this key.
+       */
+      aiVector3D mValue;
+   }
+
+   /**
+    * A time-value pair specifying a rotation for the given time. For joint
+    * animations, the rotation is usually expressed using a quaternion.
+    */
+   struct aiQuatKey {
+      /**
+       * The time of this key.
+       */
+      double mTime;
+
+      /**
+       * The value of this key.
+       */
+      aiQuaternion mValue;
+   }
+
+   /**
+    * Defines how an animation channel behaves outside the defined time
+    * range. This corresponds to <code>aiNodeAnim.mPreState</code> and
+    * <code>aiNodeAnim.mPostState</code>.
+    */
+   enum aiAnimBehaviour : uint {
+      /**
+       * The value from the default node transformation is used.
+       */
+      DEFAULT  = 0x0,
+
+      /**
+       * The nearest key value is used without interpolation.
+       */
+      CONSTANT = 0x1,
+
+      /**
+       * The value of the nearest two keys is linearly extrapolated for the
+       * current time value.
+       */
+      LINEAR = 0x2,
+
+      /**
+       * 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|).
+       */
+      REPEAT = 0x3
+   }
+
+   /**
+    * 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).
+    */
+   struct aiNodeAnim {
+      /**
+       * The name of the node affected by this animation. The node must exist
+       * and it must be unique.
+       */
+      aiString mNodeName;
+
+      /**
+       * The number of position keys.
+       */
+      uint mNumPositionKeys;
+
+      /**
+       * The position keys of this animation channel. Positions are specified
+       * as 3D vectors. The array is <code>mNumPositionKeys</code> in size.
+       *
+       * If there are position keys, there will also be at least one scaling
+       * and one rotation key.
+       */
+      aiVectorKey* mPositionKeys;
+
+      /**
+       * The number of rotation keys.
+       */
+      uint mNumRotationKeys;
+
+      /**
+       * The rotation keys of this animation channel. Rotations are given as
+       * quaternions. The array is <code>mNumRotationKeys</code> in size.
+       *
+       * If there are rotation keys, there will also be at least one scaling
+       * and one position key.
+       */
+      aiQuatKey* mRotationKeys;
+
+
+      /**
+       * The number of scaling keys.
+       */
+      uint mNumScalingKeys;
+
+      /**
+       * The scaling keys of this animation channel. Scalings are specified as
+       * 3D vectors. The array is <code>mNumScalingKeys</code> in size.
+       *
+       * If there are scaling keys, there will also be at least one position
+       * and one rotation key.
+       */
+      aiVectorKey* mScalingKeys;
+
+
+      /**
+       * Defines how the animation behaves before the first key is encountered.
+       *
+       * The default value is <code>aiAnimBehaviour.DEFAULT</code> (the original
+       * transformation matrix of the affected node is used).
+       */
+      aiAnimBehaviour mPreState;
+
+      /**
+       * Defines how the animation behaves after the last key was processed.
+       *
+       * The default value is <code>aiAnimBehaviour.DEFAULT</code> (the original
+       * transformation matrix of the affected node is used).
+       */
+      aiAnimBehaviour mPostState;
+   }
+
+   /**
+    * 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.
+    */
+   struct aiAnimation {
+      /**
+       * 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).
+       */
+      aiString mName;
+
+      /**
+       * Duration of the animation in ticks.
+       */
+      double mDuration;
+
+      /**
+       * Ticks per second. 0 if not specified in the imported file.
+       */
+      double mTicksPerSecond;
+
+      /**
+       * The number of bone animation channels.
+       *
+       * Each channel affects a single node.
+       */
+      uint mNumChannels;
+
+      /**
+       * The node animation channels. The array is <code>mNumChannels</code>
+       * in size.
+       *
+       * Each channel affects a single node.
+       */
+      aiNodeAnim** mChannels;
+   }
+}

port/dAssimp/assimp/api.d

@@ -0,0 +1,670 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * The C-style interface to the Open Asset import library.
+ *
+ * All functions of the C API have been collected in this module as function
+ * pointers, which are set by the dynamic library loader
+ * (<code>assimp.loader</code>).
+ */
+module assimp.api;
+
+import assimp.fileIO;
+import assimp.material;
+import assimp.math;
+import assimp.scene;
+import assimp.types;
+
+extern ( C ) {
+   /**
+    * Reads the given file and returns its content.
+    *
+    * If the call succeeds, the imported data is returned in an <code>aiScene</code>
+    * structure. The data is intended to be read-only, it stays property of the
+    * Assimp library and will be stable until <code>aiReleaseImport()</code> is
+    * called. After you're done with it, call <code>aiReleaseImport()</code> to
+    * free the resources associated with this file.
+    *
+    * If an error is encountered, null is returned instead. Call
+    * <code>aiGetErrorString()</code> to retrieve a human-readable error
+    * description.
+    *
+    * Params:
+    *    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
+    *       <code>aiPostProcessSteps</code> flags. If you wish to inspect the
+    *       imported scene first in order to fine-tune your post-processing
+    *       setup, consider to use <code>aiApplyPostProcessing()</code>.
+    *
+    * Returns:
+    *    A pointer to the imported data, null if the import failed.
+    */
+   aiScene* function( char* pFile, uint pFile ) aiImportFile;
+
+   /**
+    * 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 <code>aiScene</code>
+    * structure. The data is intended to be read-only, it stays property of the
+    * Assimp library and will be stable until <code>aiReleaseImport()</code> is
+    * called. After you're done with it, call <code>aiReleaseImport()</code> to
+    * free the resources associated with this file.
+    *
+    * If an error is encountered, null is returned instead. Call
+    * <code>aiGetErrorString()</code> to retrieve a human-readable error
+    * description.
+    *
+    * Params:
+    *    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
+    *       <code>aiPostProcessSteps</code> flags. If you wish to inspect the
+    *       imported scene first in order to fine-tune your post-processing
+    *       setup, consider to use <code>aiApplyPostProcessing()</code>.
+    *    pFS = An aiFileIO which will be used to open the model file itself
+    *       and any other files the loader needs to open.
+    *
+    * Returns:
+    *    A pointer to the imported data, null if the import failed.
+    */
+   aiScene* function( char* pFile, uint pFlags, aiFileIO* pFS ) aiImportFileEx;
+
+   /**
+    * Reads the scene from the given memory buffer.
+    *
+    * 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 <code>aiScene</code>
+    * structure. The data is intended to be read-only, it stays property of the
+    * Assimp library and will be stable until <code>aiReleaseImport()</code> is
+    * called. After you're done with it, call <code>aiReleaseImport()</code> to
+    * free the resources associated with this file.
+    *
+    * If an error is encountered, null is returned instead. Call
+    * <code>aiGetErrorString()</code> to retrieve a human-readable error
+    * description.
+    *
+    * Params:
+    *    pBuffer = Pointer to the scene data.
+    *    pLength = Size of pBuffer in bytes.
+    *    pFlags = Optional post processing steps to be executed after a
+    *       successful import. Provide a bitwise combination of the
+    *       <code>aiPostProcessSteps</code> flags. If you wish to inspect the
+    *       imported scene first in order to fine-tune your post-processing
+    *       setup, consider to use <code>aiApplyPostProcessing()</code>.
+    *    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 and passes the file to the first matching
+    *       loader. If this loader is unable to complete the request, the
+    *       library continues and tries to determine the file format on its
+    *       own, a task that may or may not be successful.
+    *
+    * Returns:
+    *    A pointer to the imported data, null if the import failed.
+    *
+    * Note:
+    *    This is a straightforward way to decode models from memory buffers,
+    *    but it doesn't handle model formats spreading their data across
+    *    multiple files or even directories. Examples include OBJ or MD3, which
+    *    outsource parts of their material stuff into external scripts. If you
+    *    need the full functionality, provide a custom IOSystem to make Assimp
+    *    find these files.
+    */
+   aiScene* function(
+      char* pBuffer,
+      uint pLength,
+      uint pFlags,
+      char* pHint
+   ) aiImportFileFromMemory;
+
+   /**
+    * Apply post-processing to an already-imported scene.
+    *
+    * This is strictly equivalent to calling <code>aiImportFile()</code> or
+    * <code>aiImportFileEx()</code> with the same flags. However, you can use
+    * this separate function to inspect the imported scene first to fine-tune
+    * your post-processing setup.
+    *
+    * Params:
+    *    pScene = Scene to work on.
+    *    pFlags = Provide a bitwise combination of the
+    *       <code>aiPostProcessSteps</code> flags.
+    *
+    * Returns:
+    *    A pointer to the post-processed data. Post processing is done in-place,
+    *    meaning this is still the same <code>aiScene</code> 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, <code>aiProcess.ValidateDS</code> is
+    *    currently the only post processing step which can actually cause the
+    *    scene to be reset to null.
+    */
+   aiScene* function( aiScene* pScene, uint pFlags ) aiApplyPostProcessing;
+
+   /**
+    * Get one of the predefined 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.
+    *
+    * Examples:
+    * ---
+    * aiLogStream stream = aiGetPredefinedLogStream(
+    *    aiDefaultLogStream.FILE, "assimp.log.txt" );
+    * if ( stream.callback !is null ) {
+    *    aiAttachLogStream( &stream );
+    * }
+    * ---
+    *
+    * Params:
+    *    pStreams = The log stream destination.
+    *    file = Solely for the <code>aiDefaultLogStream.FILE</code> flag:
+    *       specifies the file to write to. Pass null for all other flags.
+    *
+    * Returns:
+    *    The log stream, null if something went wrong.
+    */
+   aiLogStream function( aiDefaultLogStream pStreams, char* file ) aiGetPredefinedLogStream;
+
+   /**
+    * 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.
+    *
+    * Params:
+    *    stream = Describes the new log stream.
+    *
+    * Note: To ensure proper destruction of the logging system, you need to
+    *    manually call <code>aiDetachLogStream()</code> on every single log
+    *    stream you attach. Alternatively, <code>aiDetachAllLogStreams()</code>
+    *    is provided.
+    */
+   void function( aiLogStream* stream ) aiAttachLogStream;
+
+   /**
+    * 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 is not
+    * read correctly.
+    *
+    * Param:
+    *    d = Whether verbose logging should be enabled.
+    */
+   void function( aiBool d ) aiEnableVerboseLogging;
+
+   /**
+    * 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.
+    *
+    * Params:
+    *    stream = The log stream to be detached.
+    *
+    * Returns:
+    *    <code>aiReturn.SUCCESS</code> if the log stream has been detached
+    *    successfully.
+    *
+    * See: <code>aiDetachAllLogStreams</code>
+    */
+   aiReturn function( aiLogStream* stream ) aiDetachLogStream;
+
+   /**
+    * 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: <code>aiAttachLogStream</code>, <code>aiDetachLogStream</code>
+    */
+   void function() aiDetachAllLogStreams;
+
+   /**
+    * Releases all resources associated with the given import process.
+    *
+    * Call this function after you're done with the imported data.
+    *
+    * Params:
+    *    pScene = The imported data to release. null is a valid value.
+    */
+   void function( aiScene* pScene ) aiReleaseImport;
+
+   /**
+    * Returns the error text of the last failed import process.
+    *
+    * Returns:
+    *    A textual description of the error that occurred at the last importing
+    *    process. null if there was no error. There can't be an error if you
+    *    got a non-null <code>aiScene</code> from
+    *    <code>aiImportFile()/aiImportFileEx()/aiApplyPostProcessing()</code>.
+    */
+   char* function() aiGetErrorString;
+
+   /**
+    * Returns whether a given file extension is supported by this Assimp build.
+    *
+    * Params:
+    *    szExtension = Extension for which to query support. Must include a
+    *       leading dot '.'. Example: ".3ds", ".md3"
+    *
+    * Returns:
+    *    <code>TRUE</code> if the file extension is supported.
+    */
+   aiBool function( char* szExtension ) aiIsExtensionSupported;
+
+   /**
+    * Gets a list of all file extensions supported by ASSIMP.
+    *
+    * Format of the list: "*.3ds;*.obj;*.dae".
+    *
+    * 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.
+    *
+    * Params:
+    *    szOut = String to receive the extension list. null is not a valid
+    *       parameter.
+    */
+   void function( aiString* szOut ) aiGetExtensionList;
+
+   /**
+    * Gets the storage required by an imported asset
+    *
+    * Params:
+    *    pIn = Asset to query storage size for.
+    *    info = Data structure to be filled.
+    */
+   void function( aiScene* pIn, aiMemoryInfo* info ) aiGetMemoryRequirements;
+
+   /**
+    * Sets an integer property.
+    *
+    * Properties are always shared by all imports. It is not possible to
+    * specify them per import.
+    *
+    * Params:
+    *    szName = Name of the configuration property to be set. All supported
+    *       public properties are defined in the <code>config</code> module.
+    *    value = New value for the property.
+    */
+   void function( char* szName, int value ) aiSetImportPropertyInteger;
+
+   /**
+    * Sets a floating-point property.
+    *
+    * Properties are always shared by all imports. It is not possible to
+    * specify them per import.
+    *
+    * Params:
+    *    szName = Name of the configuration property to be set. All supported
+    *       public properties are defined in the <code>config</code> module.
+    *    value = New value for the property.
+    */
+   void function( char* szName, float value ) aiSetImportPropertyFloat;
+
+   /**
+    * Sets a string property.
+    *
+    * Properties are always shared by all imports. It is not possible to
+    * specify them per import.
+    *
+    * Params:
+    *    szName = Name of the configuration property to be set. All supported
+    *       public properties are defined in the <code>config</code> module.
+    *    st = New value for the property.
+    */
+   void function( char* szName, aiString* st ) aiSetImportPropertyString;
+
+
+   /*
+    * Mathematical helper functions.
+    */
+
+   /**
+    * Constructs a quaternion from a 3x3 rotation matrix.
+    *
+    * Params:
+    *    quat = Receives the output quaternion.
+    *    mat = Matrix to 'quaternionize'.
+    */
+   void function( aiQuaternion* quat, aiMatrix3x3* mat ) aiCreateQuaternionFromMatrix;
+
+   /**
+    * Decomposes a transformation matrix into its rotational, translational and
+    * scaling components.
+    *
+    * Params:
+    *    mat = Matrix to decompose.
+    *    scaling = Receives the scaling component.
+    *    rotation = Receives the rotational component.
+    *    position = Receives the translational component.
+    */
+   void function(
+      aiMatrix4x4* mat,
+      aiVector3D* scaling,
+      aiQuaternion* rotation,
+      aiVector3D* position
+   ) aiDecomposeMatrix;
+
+   /**
+    * Transposes a 4x4 matrix (in-place).
+    *
+    * Params:
+    *    mat = The matrix to be transposed.
+    */
+   void function( aiMatrix4x4* mat ) aiTransposeMatrix4;
+
+   /**
+    * Transposes a 3x3 matrix (in-place).
+    *
+    * Params:
+    *    mat = The matrix to be transposed.
+    */
+   void function( aiMatrix3x3* mat ) aiTransposeMatrix3;
+
+   /**
+    * Transforms a vector by a 3x3 matrix (in-place).
+    *
+    * Params:
+    *    vec = Vector to be transformed.
+    *    mat = Matrix to transform the vector with.
+    */
+   void function( aiVector3D* vec, aiMatrix3x3* mat ) aiTransformVecByMatrix3;
+
+   /**
+    * Transforms a vector by a 4x4 matrix (in-place).
+    *
+    * Params:
+    *    vec = Vector to be transformed.
+    *    mat = Matrix to transform the vector with.
+    */
+   void function( aiVector3D* vec, aiMatrix4x4* mat ) aiTransformVecByMatrix4;
+
+   /**
+    * Multiplies two 4x4 matrices.
+    *
+    * Params:
+    *    dst = First factor, receives result.
+    *    src = Matrix to be multiplied with 'dst'.
+    */
+   void function( aiMatrix4x4* dst, aiMatrix4x4* src ) aiMultiplyMatrix4;
+
+   /**
+    * Multiplies two 3x3 matrices.
+    *
+    * Params:
+    *    dst = First factor, receives result.
+    *    src = Matrix to be multiplied with 'dst'.
+    */
+   void function( aiMatrix3x3* dst, aiMatrix3x3* src ) aiMultiplyMatrix3;
+
+   /**
+    * Constructs a 3x3 identity matrix.
+    *
+    * Params:
+    *    mat = Matrix to receive its personal identity.
+    */
+   void function( aiMatrix3x3* mat ) aiIdentityMatrix3;
+
+   /**
+    * Constructs a 4x4 identity matrix.
+    *
+    * Params:
+    *    mat = Matrix to receive its personal identity.
+    */
+   void function( aiMatrix4x4* mat ) aiIdentityMatrix4;
+
+
+   /*
+    * Material system functions.
+    */
+
+   /**
+    * Retrieves a material property with a specific key from the material.
+    *
+    * Params:
+    *    pMat = Pointer to the input material. May not be null.
+    *    pKey = Key to search for. One of the <code>AI_MATKEY_XXX</code>
+    *       constants.
+    *    type = Specifies the <code>aiTextureType</code> of the texture to be
+    *       retrieved, 0 for non-texture properties.
+    *    index = Index of the texture to be retrieved,
+    *       0 for non-texture properties.
+    *    pPropOut = Pointer to receive a pointer to a valid
+    *       <code>aiMaterialProperty</code> structure or null if the key has
+    *       not been found.
+    */
+   aiReturn function(
+     aiMaterial* pMat,
+     char* pKey,
+     aiTextureType type,
+     uint index,
+     aiMaterialProperty** pPropOut
+   ) aiGetMaterialProperty;
+
+   /**
+    * Retrieves a single float value or an array of float values from the
+    * material.
+    *
+    * Examples:
+    * ---
+    * const FLOATS_IN_UV_TRANSFORM = ( aiUVTransform.sizeof / float.sizeof );
+    * uint valuesRead = FLOATS_IN_UV_TRANSFORM;
+    * bool success =
+    *    ( aiGetMaterialFloatArray( &material, AI_MATKEY_UVTRANSFORM,
+    *       aiTextureType.DIFFUSE, 0, cast( float* ) &trafo, &valuesRead ) ==
+    *       aiReturn.SUCCESS ) &&
+    *    ( valuesRead == FLOATS_IN_UV_TRANSFORM );
+    * ---
+    *
+    * Params:
+    *    pMat = Pointer to the input material. May not be null.
+    *    pKey = Key to search for. One of the AI_MATKEY_XXX constants.
+    *    type = Specifies the <code>aiTextureType</code> of the texture to be
+    *       retrieved, 0 for non-texture properties.
+    *    index = Index of the texture to be retrieved,
+    *       0 for non-texture properties.
+    *    pOut = Pointer to a buffer to receive the result.
+    *    pMax = Specifies the size of the given buffer in floats. Receives the
+    *       number of values (not bytes!) read. null to read a scalar property.
+    *
+    * Returns:
+    *    Specifies whether the key has been found. If not, the output arrays
+    *    remains unmodified and pMax is set to 0.
+    */
+   aiReturn function(
+      aiMaterial* pMat,
+      char* pKey,
+      uint type,
+      uint index,
+      float* pOut,
+      uint* pMax = null
+   ) aiGetMaterialFloatArray;
+
+   /**
+    * Convenience alias for <code>aiGetMaterialFloatArray()</code>.
+    */
+   alias aiGetMaterialFloatArray aiGetMaterialFloat;
+
+   /**
+    * Retrieves a single integer value or an array of integer values from the
+    * material.
+    *
+    * See: <code>aiGetMaterialFloatArray()</code>
+    */
+   aiReturn function(
+      aiMaterial* pMat,
+      char* pKey,
+      uint type,
+      uint index,
+      int* pOut,
+      uint* pMax = null
+   ) aiGetMaterialIntegerArray;
+
+   /**
+    * Convenience alias for <code>aiGetMaterialIntegerArray()</code>.
+    */
+   alias aiGetMaterialIntegerArray aiGetMaterialInteger;
+
+   /**
+    * Retrieves a color value from the material.
+    *
+    * See: <code>aiGetMaterialFloatArray()</code>
+    */
+   aiReturn function(
+      aiMaterial* pMat,
+      char* pKey,
+      uint type,
+      uint index,
+      aiColor4D* pOut
+   ) aiGetMaterialColor;
+
+   /**
+    * Retrieves a string value from the material.
+    *
+    * See: <code>aiGetMaterialFloatArray()</code>
+    */
+   aiReturn function(
+      aiMaterial* pMat,
+      char* pKey,
+      uint type,
+      uint index,
+      aiString* pOut
+   ) aiGetMaterialString;
+
+   /**
+    * Helper function for retrieving a texture from the material.
+    *
+    * This function is provided just for convenience. You could also read the
+    * texture by reading all of its properties manually. This function bundles
+    * all of them in a huge function-monster.
+    *
+    * Params:
+    *    mat = Pointer to the input material. May not be null.
+    *    type = Specifies the <code>aiTextureType</code> of the texture to be
+    *       retrieved.
+    *    index = Index of the texture to be retrieved.
+    *    path = Receives the output path. null is not a valid value.
+    *    mapping = Recieves the texture mapping mode to be used.
+    *       Pass null if you are not interested in this information.
+    *    uvindex = For UV-mapped textures: receives the index of the UV source
+    *       channel. Unmodified otherwise. Pass null if you are not interested
+    *       in this information.
+    *    blend = Receives the blend factor for the texture.
+    *       Pass null if you are not interested in this information.
+    *    op = Receives the texture blend operation to be perform between this
+    *       texture and the previous texture. Pass null if you are not
+    *       interested in this information.
+    *    mapmode = Receives the mapping modes to be used for the texture. Pass
+    *       a pointer to an array of two aiTextureMapMode's (one for each axis,
+    *       UV order) or null if you are not interested in this information.
+    *
+    * Returns:
+    *    <code>aiReturn.SUCCESS</code> on success, something else otherwise.
+    */
+   aiReturn function(
+      aiMaterial* mat,
+      aiTextureType type,
+      uint index,
+      aiString* path,
+      aiTextureMapping* mapping = null,
+      uint* uvindex = null,
+      float* blend = null,
+      aiTextureOp* op = null,
+      aiTextureMapMode* mapmode = null
+   ) aiGetMaterialTexture;
+
+
+   /*
+    * Versioning functions.
+    */
+
+   /**
+    * Returns a string with legal copyright and licensing information about
+    * Assimp.
+    *
+    * The string may include multiple lines.
+    *
+    * Returns:
+    *    Pointer to static string.
+    */
+   char* function() aiGetLegalString;
+
+   /**
+    * Returns the current minor version number of the Assimp library.
+    *
+    * Returns:
+    *    Minor version of the Assimp library.
+    */
+   uint function() aiGetVersionMinor;
+
+   /**
+    * Returns the current major version number of the Assimp library.
+    *
+    * Returns:
+    *    Major version of the Assimp library.
+    */
+   uint function() aiGetVersionMajor;
+
+   /**
+    * Returns the repository revision of the Assimp library.
+    *
+    * Returns:
+    *    SVN Repository revision number of the Assimp library.
+    */
+   uint function() aiGetVersionRevision;
+
+   /**
+    * Returns the flags Assimp was compiled with.
+    *
+    * Returns:
+    *    Any bitwise combination of the ASSIMP_CFLAGS_xxx constants.
+    */
+   uint function() aiGetCompileFlags;
+}

port/dAssimp/assimp/assimp.d

@@ -0,0 +1,63 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Include-all module provided for convenience.
+ */
+module assimp.assimp;
+
+public {
+   import assimp.animation;
+   import assimp.api;
+   import assimp.camera;
+   import assimp.config;
+   import assimp.fileIO;
+   import assimp.light;
+   import assimp.loader;
+   import assimp.material;
+   import assimp.math;
+   import assimp.mesh;
+   import assimp.postprocess;
+   import assimp.scene;
+   import assimp.texture;
+   import assimp.types;
+   import assimp.versionInfo;
+}

port/dAssimp/assimp/camera.d

@@ -0,0 +1,182 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Contains the data structure which is used to store the imported information
+ * about the virtual cameras in the scene.
+ */
+module assimp.camera;
+
+import assimp.math;
+import assimp.types;
+
+extern ( C ) {
+   /**
+    * 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 <em>relative</em> to the coordinate system defined
+    * by the node which corresponds to the camera. This allows for camera
+    * animations. Static cameras parameters like the look-at or up vectors are
+    * usually specified directly in the class members, but beware, they could
+    * also be encoded in the node transformation. The following (pseudo)code
+    * sample shows how to do it.
+    *
+    * Examples:
+    * ---
+    * // 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; the
+    *    transformation applied to the main camera node already makes the
+    *    camera face the right direction.
+    */
+   struct aiCamera {
+      /**
+       * 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.
+       */
+      aiString mName;
+
+
+      /**
+       * Position of the camera relative to the coordinate space defined by the
+       * corresponding node.
+       *
+       * The default value is 0|0|0.
+       */
+      aiVector3D mPosition;
+
+      /**
+       * 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.
+       */
+      aiVector3D mUp;
+
+      /**
+       * Look-at 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.
+       */
+      aiVector3D mLookAt;
+
+
+      /**
+       * 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 PI/4.
+       */
+      float mHorizontalFOV;
+
+      /**
+       * 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 mClipPlaneNear;
+
+      /**
+       * Distance of the far clipping plane from the camera.
+       *
+       * The far clipping plane must, of course, be further away than the
+       * near clipping plane. The 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.
+       *
+       * The default value is 1000.f.
+       */
+      float mClipPlaneFar;
+
+      /**
+       * 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 mAspect;
+   }
+}

port/dAssimp/assimp/config.d

@@ -0,0 +1,626 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Defines constants for configurable properties for the library.
+ *
+ * These are set via <code>aiSetImportPropertyInteger()</code>,
+ * <code>aiSetImportPropertyFloat()</code> and
+ * <code>aiSetImportPropertyString()</code>.
+ */
+module assimp.config;
+
+extern ( C ) {
+   /*
+    * Post processing settings.
+    *
+    * Various options to fine-tune the behavior of a specific post processing step.
+    */
+
+   /**
+    * Specifies the maximum angle that may be between two vertex tangents that
+    * their tangents and bitangents are smoothed.
+    *
+    * This applies to the <code>CalcTangentSpace</code> step. The angle is
+    * specified in degrees, so 180 corresponds to PI radians.
+    *
+    * The default value is 45, the maximum value is 175.
+    *
+    * Property type: float.
+    */
+   const char* AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE = "PP_CT_MAX_SMOOTHING_ANGLE";
+
+   /**
+    * Specifies the maximum angle that may be between two face normals at the
+    * same vertex position that their are smoothed together. Sometimes referred
+    * to as 'crease angle'.
+    *
+    * This applies to the <code>GenSmoothNormals</code> step. The angle is
+    * specified in degrees, so 180 corresponds to PI radians.
+    *
+    * The default value is 175 degrees (all vertex normals are smoothed), the
+    * maximum value is 175, too.
+    *
+    * Property type: float.
+    *
+    * Warning:
+    *    Setting this option may cause a severe loss of performance. The
+    *    performance is unaffected if the <code>AI_CONFIG_FAVOUR_SPEED</code>
+    *    flag is set but the output quality may be reduced.
+    */
+   const char* AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE = "PP_GSN_MAX_SMOOTHING_ANGLE";
+
+   /**
+    * Sets the colormap (= palette) to be used to decode embedded textures in
+    * MDL (Quake or 3DGS) files.
+    *
+    * This must be a valid path to a file. The file is 768 (256*3) bytes large
+    * and contains RGB triplets for each of the 256 palette entries. The
+    * default value is colormap.lmp. If the file is not found, a default
+    * palette (from Quake 1) is used.
+    *
+    * Property type: string.
+    */
+   const char* AI_CONFIG_IMPORT_MDL_COLORMAP = "IMPORT_MDL_COLORMAP";
+
+   /**
+    * Configures the <code>RemoveRedundantMaterials</code> step to keep
+    * materials matching a name in a given list.
+    *
+    * This is a list of 1 to n strings, ' ' serves as delimiter character.
+    * Identifiers containing whitespaces must be enclosed in <em>single</em>
+    * quotation marks. For example: <code>
+    * "keep-me and_me_to anotherMaterialToBeKept \'name with whitespace\'"</code>.
+    * Linefeeds, tabs or carriage returns are treated as whitespace.
+    *
+    * If a material matches on of these names, it will not be modified or
+    * removed by the postprocessing step nor will other materials be replaced
+    * by a reference to it.
+    *
+    * This option might be useful if you are using some magic material names
+    * to pass additional semantics through the content pipeline. This ensures
+    * they won't be optimized away, but a general optimization is still
+    * performed for materials not contained in the list.
+    *
+    * Default value: n/a
+    *
+    * Property type: string.
+    *
+    * Note: Material names are case sensitive.
+    */
+   const char* AI_CONFIG_PP_RRM_EXCLUDE_LIST = "PP_RRM_EXCLUDE_LIST";
+
+   /**
+    * Configures the <code>PretransformVertices</code> step to keep the scene
+    * hierarchy. Meshes are moved to worldspace, but no optimization is
+    * performed (means: meshes are not joined. The total number of meshes won't
+    * change).
+    *
+    * This option could be of use for you if the scene hierarchy contains
+    * important additional information which you want to interpret.
+    * For rendering, you can still render all meshes in the scene without
+    * any transformations.
+    *
+    * Default value: false.
+    *
+    * Property type: integer (0: false; !0: true).
+    */
+   const char* AI_CONFIG_PP_PTV_KEEP_HIERARCHY = "PP_PTV_KEEP_HIERARCHY";
+
+   /**
+    * Configures the <code>FindDegenerates</code> step to remove degenerated
+    * primitives from the import – immediately.
+    *
+    * The default behaviour converts degenerated triangles to lines and
+    * degenerated lines to points. See the documentation to the
+    * <code>FindDegenerates</code> step for a detailed example of the various
+    * ways to get rid of these lines and points if you don't want them.
+    *
+    * Default value: false.
+    *
+    * Property type: integer (0: false; !0: true).
+    */
+   const char* AI_CONFIG_PP_FD_REMOVE = "PP_FD_REMOVE";
+
+   /**
+    * Configures the <code>OptimizeGraph</code> step to preserve nodes matching
+    * a name in a given list.
+    *
+    * This is a list of 1 to n strings, ' ' serves as delimiter character.
+    * Identifiers containing whitespaces must be enclosed in <em>single</em>
+    * quotation marks. For example: <code>
+    * "keep-me and_me_to anotherMaterialToBeKept \'name with whitespace\'"</code>.
+    * Linefeeds, tabs or carriage returns are treated as whitespace.
+    *
+    * If a node matches on of these names, it will not be modified or
+    * removed by the postprocessing step.
+    *
+    * This option might be useful if you are using some magic node names
+    * to pass additional semantics through the content pipeline. This ensures
+    * they won't be optimized away, but a general optimization is still
+    * performed for nodes not contained in the list.
+    *
+    * Default value: n/a
+    *
+    * Property type: string.
+    *
+    * Note: Node names are case sensitive.
+    */
+   const char* AI_CONFIG_PP_OG_EXCLUDE_LIST = "PP_OG_EXCLUDE_LIST";
+
+   /**
+    * Sets the maximum number of triangles in a mesh.
+    *
+    * This is used by the <code>SplitLargeMeshes</code> step to determine
+    * whether a mesh must be split or not.
+    *
+    * Default value: AI_SLM_DEFAULT_MAX_TRIANGLES.
+    *
+    * Property type: integer.
+    */
+   const char* AI_CONFIG_PP_SLM_TRIANGLE_LIMIT = "PP_SLM_TRIANGLE_LIMIT";
+
+   /**
+    * The default value for the AI_CONFIG_PP_SLM_TRIANGLE_LIMIT setting.
+    */
+   const AI_SLM_DEFAULT_MAX_TRIANGLES = 1000000;
+
+   /**
+    * Sets the maximum number of vertices in a mesh.
+    *
+    * This is used by the <code>SplitLargeMeshes</code> step to determine
+    * whether a mesh must be split or not.
+    *
+    * Default value: AI_SLM_DEFAULT_MAX_VERTICES
+    *
+    * Property type: integer.
+    */
+   const char* AI_CONFIG_PP_SLM_VERTEX_LIMIT = "PP_SLM_VERTEX_LIMIT";
+
+   /**
+    * The default value for the AI_CONFIG_PP_SLM_VERTEX_LIMIT setting.
+    */
+   const AI_SLM_DEFAULT_MAX_VERTICES = 1000000;
+
+   /**
+    * Sets the maximum number of bones affecting a single vertex.
+    *
+    * This is used by the <code>LimitBoneWeights</code> step.
+    *
+    * Default value: AI_LBW_MAX_WEIGHTS
+    *
+    * Property type: integer.
+    */
+   const char* AI_CONFIG_PP_LBW_MAX_WEIGHTS = "PP_LBW_MAX_WEIGHTS";
+
+   /**
+    * The default value for the AI_CONFIG_PP_LBW_MAX_WEIGHTS setting.
+    */
+   const AI_LMW_MAX_WEIGHTS = 0x4;
+
+   /**
+    * Sets the size of the post-transform vertex cache to optimize the
+    * vertices for. This configures the <code>ImproveCacheLocality</code> step.
+    *
+    * The size is given in vertices. Of course you can't know how the vertex
+    * format will exactly look like after the import returns, but you can still
+    * guess what your meshes will probably have.
+    *
+    * The default value results in slight performance improvements for most
+    * nVidia/AMD cards since 2002.
+    *
+    * Default value: PP_ICL_PTCACHE_SIZE
+    *
+    * Property type: integer.
+    */
+   const char* AI_CONFIG_PP_ICL_PTCACHE_SIZE = "PP_ICL_PTCACHE_SIZE";
+
+   /**
+    * The default value for the AI_CONFIG_PP_ICL_PTCACHE_SIZE config option.
+    */
+   const PP_ICL_PTCACHE_SIZE = 12;
+
+   /**
+    * Components of the <code>aiScene</code> and <code>aiMesh</code> data
+    * structures that can be excluded from the import by using the
+    * <code>RemoveComponent</code> step.
+    *
+    *  See the documentation to <code>RemoveComponent</code> for more details.
+    */
+   enum aiComponent : uint {
+      /**
+       * Normal vectors.
+       */
+      NORMALS = 0x2,
+
+      /**
+       * Tangents and bitangents.
+       */
+      TANGENTS_AND_BITANGENTS = 0x4,
+
+      /**
+       * <em>All</em> color sets.
+       *
+       * Use aiComponent_COLORSn( N ) to specify the N'th set.
+       */
+      COLORS = 0x8,
+
+      /**
+       * <em>All</em> texture UV coordinate sets.
+       *
+       * Use aiComponent_TEXCOORDn( N ) to specify the N'th set.
+       */
+      TEXCOORDS = 0x10,
+
+      /**
+       * Bone weights from all meshes.
+       *
+       * The corresponding scenegraph nodes are <em>not</em> removed. Use the
+       * <code>OptimizeGraph</code> step to do this.
+       */
+      BONEWEIGHTS = 0x20,
+
+      /**
+       * Node animations (<code>aiScene.mAnimations</code>).
+       *
+       * The corresponding scenegraph nodes are <em>not</em> removed. Use the
+       * <code>OptimizeGraph</code> step to do this.
+       */
+      ANIMATIONS = 0x40,
+
+      /**
+       * Embedded textures (<code>aiScene.mTextures</code>).
+      */
+      TEXTURES = 0x80,
+
+      /**
+       * Light sources (<code>aiScene.mLights</code>).
+       *
+       * The corresponding scenegraph nodes are <em>not</em> removed. Use the
+       * <code>OptimizeGraph</code> step to do this.
+       */
+      LIGHTS = 0x100,
+
+      /**
+       * Cameras (<code>aiScene.mCameras</code>).
+       *
+       * The corresponding scenegraph nodes are <em>not</em> removed. Use the
+       * <code>OptimizeGraph</code> step to do this.
+       */
+      CAMERAS = 0x200,
+
+      /**
+       * Meshes (<code>aiScene.mMeshes</code>).
+       */
+      MESHES = 0x400,
+
+      /** Materials.
+       *
+       * One default material will be generated, so
+       * <code>aiScene.mNumMaterials</code> will be 1.
+      */
+      MATERIALS = 0x800
+   }
+
+   /**
+    * Specifies a certain color channel to remove.
+    */
+   uint aiComponent_COLORSn( uint n ) { return 1u << ( n + 20u ); }
+
+   /**
+    * Specifies a certain UV coordinate channel to remove.
+    */
+   uint aiComponent_TEXCOORDSn( uint n ) { return 1u << ( n + 25u ); }
+
+   /**
+    * Input parameter to the <code>RemoveComponent</code> step:
+    * Specifies the parts of the data structure to be removed.
+    *
+    * See the documentation to this step for further details.
+    *
+    * Default value: 0
+    *
+    * Property type: integer (bitwise combination of <code>aiComponent</code>
+    * flags).
+    *
+    * Note: If no valid mesh is remaining after the step has been executed, the
+    *    import <em>fails</em>, because there is no data to work on anymore.
+    */
+   const char* AI_CONFIG_PP_RVC_FLAGS = "PP_RVC_FLAGS";
+
+   /**
+    * Input parameter to the <code>SortByPType</code> step:
+    * Specifies which primitive types are removed by the step.
+    *
+    * This is a bitwise combination of the <code>aiPrimitiveType</code> flags.
+    * Specifying all of them is illegal, of course. A typical use would be to
+    * exclude all line and point meshes from the import.
+    *
+    * Default value: 0
+    *
+    * Property type: integer.
+    */
+   const char* AI_CONFIG_PP_SBP_REMOVE = "PP_SBP_REMOVE";
+
+
+   /**
+    * The <code>TransformUVCoords</code> step evaluates UV scalings.
+    */
+   const AI_UVTRAFO_SCALING = 0x1;
+
+   /**
+    * The <code>TransformUVCoords</code> step evaluates UV rotations.
+    */
+   const AI_UVTRAFO_ROTATION = 0x2;
+
+   /**
+    * The <code>TransformUVCoords</code> step evaluates UV translation.
+    */
+   const AI_UVTRAFO_TRANSLATION = 0x4;
+
+   /**
+    * The <code>TransformUVCoords</code> step evaluates all UV translations.
+    */
+   const AI_UVTRAFO_ALL =
+      AI_UVTRAFO_SCALING
+      | AI_UVTRAFO_ROTATION
+      | AI_UVTRAFO_TRANSLATION;
+
+   /**
+    * Input parameter to the <code>TransformUVCoords</code> step: Specifies
+    * which UV transformations are evaluated.
+    *
+    * Default value: AI_UVTRAFO_ALL.
+    *
+    * Property type: integer (bitwise combination of the
+    * <code>AI_UVTRAFO_XXX<code> flag).
+    */
+   const char* AI_CONFIG_PP_TUV_EVALUATE = "PP_TUV_EVALUATE";
+
+   /**
+    * A hint to assimp to favour speed against import quality.
+    *
+    * Enabling this option may result in faster loading, but it needn't.
+    * It represents just a hint to loaders and post-processing steps to use
+    * faster code paths, if possible.
+    *
+    * Default value: false.
+    *
+    * Property type: integer (0: false; !0: true).
+    */
+   const char* AI_CONFIG_FAVOUR_SPEED = "FAVOUR_SPEED";
+
+
+   /*
+    * Importer settings.
+    *
+    * Various stuff to fine-tune the behaviour of a specific importer plugin.
+    */
+
+   /**
+    * Set the vertex animation keyframe to be imported.
+    *
+    * Assimp does not support vertex keyframes (only bone animation is
+    * supported). The library reads only one frame of models with vertex
+    * animations.
+    *
+    * Default value: 0 (first frame).
+    *
+    * Property type: integer.
+    *
+    * Note: This option applies to all importers. However, it is also possible
+    *    to override the global setting for a specific loader. You can use the
+    *    AI_CONFIG_IMPORT_XXX_KEYFRAME options (where XXX is a placeholder for
+    *    the file format for which you want to override the global setting).
+    */
+   const char* AI_CONFIG_IMPORT_GLOBAL_KEYFRAME = "IMPORT_GLOBAL_KEYFRAME";
+
+   const char* AI_CONFIG_IMPORT_MD3_KEYFRAME = "IMPORT_MD3_KEYFRAME";
+   const char* AI_CONFIG_IMPORT_MD2_KEYFRAME = "IMPORT_MD2_KEYFRAME";
+   const char* AI_CONFIG_IMPORT_MDL_KEYFRAME = "IMPORT_MDL_KEYFRAME";
+   const char* AI_CONFIG_IMPORT_MDC_KEYFRAME = "IMPORT_MDC_KEYFRAME";
+   const char* AI_CONFIG_IMPORT_SMD_KEYFRAME = "IMPORT_SMD_KEYFRAME";
+   const char* AI_CONFIG_IMPORT_UNREAL_KEYFRAME = "IMPORT_UNREAL_KEYFRAME";
+
+
+   /**
+    * Configures the AC loader to collect all surfaces which have the
+    * "Backface cull" flag set in separate meshes.
+    *
+    * Default value: true.
+    *
+    * Property type: integer (0: false; !0: true).
+    */
+   const char* AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL = "IMPORT_AC_SEPARATE_BFCULL";
+
+   /**
+    * Configures the UNREAL 3D loader to separate faces with different surface
+    * flags (e.g. two-sided vs. single-sided).
+    *
+    * Default value: true.
+    *
+    * Property type: integer (0: false; !0: true).
+    */
+   const char* AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS = "UNREAL_HANDLE_FLAGS";
+
+   /**
+    * Configures the terragen import plugin to compute uv's for terrains, if
+    * not given. Furthermore, a default texture is assigned.
+    *
+    * UV coordinates for terrains are so simple to compute that you'll usually
+    * want to compute them on your own, if you need them. This option is intended
+    * for model viewers which want to offer an easy way to apply textures to
+    * terrains.
+    *
+    * Default value: false.
+    *
+    * Property type: integer (0: false; !0: true).
+    */
+   const char* AI_CONFIG_IMPORT_TER_MAKE_UVS = "IMPORT_TER_MAKE_UVS";
+
+   /**
+    * Configures the ASE loader to always reconstruct normal vectors basing on
+    * the smoothing groups loaded from the file.
+    *
+    * Many ASE files have invalid normals (they're not orthonormal).
+    *
+    * Default value: true.
+    *
+    * Property type: integer (0: false; !0: true).
+    */
+   const char* AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS = "IMPORT_ASE_RECONSTRUCT_NORMALS";
+
+   /**
+    * Configures the M3D loader to process multi-part player models.
+    *
+    * These models usually consist of three files, <code>lower.md3</code>,
+    * <code>upper.md3</code> and <code>head.md3</code>. If this property is set
+    * to true, Assimp will try to load and combine all three files if one of
+    * them is loaded.
+    *
+    * Default value: true.
+    *
+    * Property type: integer (0: false; !0: true).
+    */
+   const char* AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART = "IMPORT_MD3_HANDLE_MULTIPART";
+
+   /**
+    * Tells the MD3 loader which skin files to load.
+    *
+    * When loading MD3 files, Assimp checks whether a file
+    * <code><md3_file_name>_<skin_name>.skin</code> is existing. These files
+    * are used by Quake 3 to be able to assign different skins (e.g. red and
+    * blue team) to models. 'default', 'red', 'blue' are typical skin names.
+    *
+    * Default value: "default".
+    *
+    * Property type: string.
+    */
+   const char* AI_CONFIG_IMPORT_MD3_SKIN_NAME = "IMPORT_MD3_SKIN_NAME";
+
+   /**
+    * Specify the Quake 3 shader file to be used for a particular MD3 file.
+    * This can also be a search path.
+    *
+    * By default Assimp's behaviour is as follows: If a MD3 file
+    * <code>[any_path]/models/[any_q3_subdir]/[model_name]/[file_name].md3</code>
+    * is loaded, the library tries to locate the corresponding shader file in
+    * <code>[any_path]/scripts/[model_name].shader</code>. This property
+    * overrides this behaviour. It can either specify a full path to the shader
+    * to be loaded or alternatively the path (relative or absolute) to the
+    * directory where the shaders for all MD3s to be loaded reside. Assimp
+    * attempts to open <code>[dir]/[model_name].shader</code> first,
+    * <code>[dir]/[file_name].shader</code> is the fallback file. Note that
+    * <code>[dir]</code> should have a terminal (back)slash.
+    *
+    * Default value: n/a.
+    *
+    * Property type: string.
+    */
+   const char* AI_CONFIG_IMPORT_MD3_SHADER_SRC = "IMPORT_MD3_SHADER_SRC";
+
+   /**
+    * Configures the LWO loader to load just one layer from the model.
+    *
+    * LWO files consist of layers and in some cases it could be useful to load
+    * only one of them. This property can be either a string – which specifies
+    * the name of the layer – or an integer – the index of the layer. If the
+    * property is not set the whole LWO model is loaded. Loading fails if the
+    * requested layer is not available. The layer index is zero-based and the
+    * layer name may not be empty.
+    *
+    * Default value: all layers are loaded.
+    *
+    * Property type: integer/string.
+    */
+   const char* AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY = "IMPORT_LWO_ONE_LAYER_ONLY";
+
+   /**
+    * Configures the MD5 loader to not load the MD5ANIM file for a MD5MESH file
+    * automatically.
+    *
+    * The default strategy is to look for a file with the same name but the
+    * MD5ANIM extension in the same directory. If it is found, it is loaded
+    * and combined with the MD5MESH file. This configuration option can be
+    * used to disable this behaviour.
+    *
+    * Default value: false.
+    *
+    * Property type: integer (0: false; !0: true).
+    */
+   const char* AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD = "IMPORT_MD5_NO_ANIM_AUTOLOAD";
+
+   /**
+    * Defines the begin of the time range for which the LWS loader evaluates
+    * animations and computes <code>aiNodeAnim</code>s.
+    *
+    * Assimp provides full conversion of LightWave's envelope system, including
+    * pre and post conditions. The loader computes linearly subsampled animation
+    * chanels with the frame rate given in the LWS file. This property defines
+    * the start time. Note: animation channels are only generated if a node
+    * has at least one envelope with more tan one key assigned. This property.
+    * is given in frames, '0' is the first frame. By default, if this property
+    * is not set, the importer takes the animation start from the input LWS
+    * file ('FirstFrame' line).
+    *
+    * Default value: read from file.
+    *
+    * Property type: integer.
+    *
+    * See: <code>AI_CONFIG_IMPORT_LWS_ANIM_END</code> – end of the imported
+    *    time range
+    */
+   const char* AI_CONFIG_IMPORT_LWS_ANIM_START = "IMPORT_LWS_ANIM_START";
+   const char* AI_CONFIG_IMPORT_LWS_ANIM_END = "IMPORT_LWS_ANIM_END";
+
+   /**
+    * Defines the output frame rate of the IRR loader.
+    *
+    * IRR animations are difficult to convert for Assimp and there will always
+    * be a loss of quality. This setting defines how many keys per second are
+    * returned by the converter.
+    *
+    * Default value: 100.
+    *
+    * Property type: integer.
+    */
+   const char* AI_CONFIG_IMPORT_IRR_ANIM_FPS = "IMPORT_IRR_ANIM_FPS";
+}

port/dAssimp/assimp/fileIO.d

@@ -0,0 +1,140 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * The data structures necessary to use Assimip with a custom IO system.
+ */
+module assimp.fileIO;
+
+import assimp.types;
+
+extern ( C ) {
+   // aiFile callbacks
+   alias size_t function( aiFile*, char*, size_t, size_t ) aiFileWriteProc;
+   alias size_t function(  aiFile*, char*, size_t, size_t ) aiFileReadProc;
+   alias size_t function( aiFile* ) aiFileTellProc;
+   alias void function( aiFile* ) aiFileFlushProc;
+   alias aiReturn function( aiFile*, size_t, aiOrigin ) aiFileSeek;
+
+   // aiFileIO callbacks
+   alias aiFile* function( aiFileIO*, char*, char* ) aiFileOpenProc;
+   alias void function( aiFileIO*,  aiFile* ) aiFileCloseProc;
+
+   /**
+    * Represents user-defined data.
+    */
+   alias char* aiUserData;
+
+   /**
+    * 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.
+    */
+   struct aiFileIO {
+      /**
+       * Function used to open a new file
+       */
+      aiFileOpenProc OpenProc;
+
+      /**
+       * Function used to close an existing file
+       */
+      aiFileCloseProc CloseProc;
+
+      /**
+       * User-defined, opaque data.
+       */
+      aiUserData UserData;
+   }
+
+   /**
+    * Represents a read/write file.
+    *
+    * Actually, it's a data structure to wrap a set of <code>fXXXX</code>
+    * (e.g <code>fopen()</code>) replacement functions.
+    *
+    * The default implementation of the functions utilizes the <code>fXXX</code>
+    * functions from the CRT. However, you can supply a custom implementation
+    * to Assimp by passing a custom <code>aiFileIO</code>. Use this to enable
+    * reading from other sources such as ZIP archives or memory locations.
+    */
+   struct aiFile {
+      /**
+       * Callback to read from a file.
+       */
+      aiFileReadProc ReadProc;
+
+      /**
+       * Callback to write to a file.
+       */
+      aiFileWriteProc WriteProc;
+
+      /**
+       * Callback to retrieve the current position of the file cursor
+       * (<code>ftell()</code>).
+       */
+      aiFileTellProc TellProc;
+
+      /**
+       * Callback to retrieve the size of the file, in bytes.
+       */
+      aiFileTellProc FileSizeProc;
+
+      /**
+       * Callback to set the current position of the file cursor
+       * (<code>fseek()</code>).
+       */
+      aiFileSeek SeekProc;
+
+      /**
+       * Callback to flush the file contents.
+       */
+      aiFileFlushProc FlushProc;
+
+      /**
+       * User-defined, opaque data.
+       */
+      aiUserData UserData;
+   }
+}

port/dAssimp/assimp/light.d

@@ -0,0 +1,215 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Contains the data structures which are used to store the imported information
+ * about the light sources in the scene.
+ */
+module assimp.light;
+
+import assimp.math;
+import assimp.types;
+
+extern ( C ) {
+   /**
+    * Enumerates all supported types of light sources.
+    */
+   enum aiLightSourceType : uint {
+      UNDEFINED = 0x0,
+
+      /**
+       * A directional light source has a well-defined direction but is
+       * infinitely far away. That's quite a good approximation for sun light.
+       */
+      DIRECTIONAL = 0x1,
+
+      /**
+       * 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.
+       */
+      POINT = 0x2,
+
+      /**
+       * 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.
+       */
+      SPOT = 0x3
+   }
+
+   /**
+    * 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
+    * <code>[spotName].Target</code>. However, this is just additional
+    * information then, the transformation tracks of the main node make the
+    * spot light already point in the right direction.
+   */
+   struct aiLight {
+      /**
+       * 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 scenehierarchy and can be
+       * animated.
+       */
+      aiString mName;
+
+      /**
+       * The type of the light source.
+       *
+       * <code>aiLightSource.UNDEFINED</code> is not a valid value for this
+       * member.
+       */
+      aiLightSourceType mType;
+
+      /**
+       * 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.
+       */
+      aiVector3D mPosition;
+
+      /**
+       * 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.
+       */
+      aiVector3D mDirection;
+
+      /**
+       * Constant light attenuation factor.
+       *
+       * The intensity of the light source at a given distance
+       * <code>d</code> from the light's position is
+       * <code>1/( att0 + att1 * d + att2 * d * d )</code>. This member
+       * corresponds to the <code>att0</code> variable in the equation.
+       *
+       * Naturally undefined for directional lights.
+       */
+      float mAttenuationConstant;
+
+      /**
+       * Linear light attenuation factor.
+       *
+       * The intensity of the light source at a given distance
+       * <code>d</code> from the light's position is
+       * <code>1/( att0 + att1 * d + att2 * d * d )</code>. This member
+       * corresponds to the <code>att1</code> variable in the equation.
+       *
+       * Naturally undefined for directional lights.
+       */
+      float mAttenuationLinear;
+
+      /**
+       * Quadratic light attenuation factor.
+       *
+       * The intensity of the light source at a given distance
+       * <code>d</code> from the light's position is
+       * <code>1/( att0 + att1 * d + att2 * d * d )</code>. This member
+       * corresponds to the <code>att2</code> variable in the equation.
+       *
+       * Naturally undefined for directional lights.
+       */
+      float mAttenuationQuadratic;
+
+      /**
+       * 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 mColorDiffuse;
+
+      /**
+       * 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.
+       */
+      aiColor3D mColorSpecular;
+
+      /**
+       * 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 mColorAmbient;
+
+      /**
+       * 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 mAngleInnerCone;
+
+      /**
+       * 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 mAngleOuterCone;
+   }
+}

port/dAssimp/assimp/loader.d

@@ -0,0 +1,203 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Provides facilities for dynamically loading the Assimp library.
+ *
+ * Currently requires Tango, but there is no reason why Phobos could not be
+ * supported too.
+ */
+module assimp.loader;
+
+import assimp.api;
+import tango.io.Stdout;
+import tango.sys.SharedLib;
+
+const uint ASSIMP_BINDINGS_MAJOR = 0;
+const uint ASSIMP_BINDINGS_MINOR = 5;
+
+/**
+ * Loader class for dynamically loading the Assimp library.
+ *
+ * The library is »reference-counted«, meaning that the library is not
+ * unloaded on a call to <code>unload()</code> if there are still other
+ * references to it.
+ */
+struct Assimp {
+public:
+   /**
+    * Loads the library if it is not already loaded and increases the
+    * reference counter.
+    *
+    * The library file (<code>libassimp.so</code> on POSIX systems,
+    * <code>Assimp32.dll</code> on Win32) is loaded via Tango's SharedLib
+    * class.
+    */
+   static void load() {
+      if ( m_sRefCount == 0 ) {
+         version ( Posix ) {
+            m_sLibrary = SharedLib.load( "libassimp.so" );
+         }
+         version ( Win32 ) {
+            m_sLibrary = SharedLib.load( "Assimp32.dll" );
+         }
+
+         // Versioning
+         bind( aiGetLegalString )( "aiGetLegalString" );
+         bind( aiGetVersionMinor )( "aiGetVersionMinor" );
+         bind( aiGetVersionMajor )( "aiGetVersionMajor" );
+         bind( aiGetVersionRevision )( "aiGetVersionRevision" );
+         bind( aiGetCompileFlags )( "aiGetCompileFlags" );
+
+         // Check for version mismatch between the external, dynamically loaded
+         // library and the version the bindings were created against.
+         uint libMajor = aiGetVersionMajor();
+         uint libMinor = aiGetVersionMinor();
+
+         if ( ( libMajor < ASSIMP_BINDINGS_MAJOR ) ||
+            ( libMinor < ASSIMP_BINDINGS_MINOR ) ) {
+            Stdout.format(
+               "WARNING: Assimp version too old (loaded library: {}.{}, " ~
+                  "bindings: {}.{})!",
+               libMajor,
+               libMinor,
+               ASSIMP_BINDINGS_MAJOR,
+               ASSIMP_BINDINGS_MINOR
+            ).newline;
+         }
+
+         if ( libMajor > ASSIMP_BINDINGS_MAJOR ) {
+            Stdout.format(
+               "WARNING: Assimp version too new (loaded library: {}.{}, " ~
+                  "bindings: {}.{})!",
+               libMajor,
+               libMinor,
+               ASSIMP_BINDINGS_MAJOR,
+               ASSIMP_BINDINGS_MINOR
+            ).newline;
+         }
+
+         // General API
+         bind( aiImportFile )( "aiImportFile" );
+         bind( aiImportFileEx )( "aiImportFileEx" );
+         bind( aiImportFileFromMemory )( "aiImportFileFromMemory" );
+         bind( aiApplyPostProcessing )( "aiApplyPostProcessing" );
+         bind( aiGetPredefinedLogStream )( "aiGetPredefinedLogStream" );
+         bind( aiAttachLogStream )( "aiAttachLogStream" );
+         bind( aiEnableVerboseLogging )( "aiEnableVerboseLogging" );
+         bind( aiDetachLogStream )( "aiDetachLogStream" );
+         bind( aiDetachAllLogStreams )( "aiDetachAllLogStreams" );
+         bind( aiReleaseImport )( "aiReleaseImport" );
+         bind( aiGetErrorString )( "aiGetErrorString" );
+         bind( aiIsExtensionSupported )( "aiIsExtensionSupported" );
+         bind( aiGetExtensionList )( "aiGetExtensionList" );
+         bind( aiGetMemoryRequirements )( "aiGetMemoryRequirements" );
+         bind( aiSetImportPropertyInteger )( "aiSetImportPropertyInteger" );
+         bind( aiSetImportPropertyFloat )( "aiSetImportPropertyFloat" );
+         bind( aiSetImportPropertyString )( "aiSetImportPropertyString" );
+
+         // Mathematical functions
+         bind( aiCreateQuaternionFromMatrix )( "aiCreateQuaternionFromMatrix" );
+         bind( aiDecomposeMatrix )( "aiDecomposeMatrix" );
+         bind( aiTransposeMatrix4 )( "aiTransposeMatrix4" );
+         bind( aiTransposeMatrix3 )( "aiTransposeMatrix3" );
+         bind( aiTransformVecByMatrix3 )( "aiTransformVecByMatrix3" );
+         bind( aiTransformVecByMatrix4 )( "aiTransformVecByMatrix4" );
+         bind( aiMultiplyMatrix4 )( "aiMultiplyMatrix4" );
+         bind( aiMultiplyMatrix3 )( "aiMultiplyMatrix3" );
+         bind( aiIdentityMatrix3 )( "aiIdentityMatrix3" );
+         bind( aiIdentityMatrix4 )( "aiIdentityMatrix4" );
+
+         // Material system
+         //bind( aiGetMaterialProperty )( "aiGetMaterialProperty" );
+         bind( aiGetMaterialFloatArray )( "aiGetMaterialFloatArray" );
+         bind( aiGetMaterialIntegerArray )( "aiGetMaterialIntegerArray" );
+         bind( aiGetMaterialColor )( "aiGetMaterialColor" );
+         bind( aiGetMaterialString )( "aiGetMaterialString" );
+         bind( aiGetMaterialTexture )( "aiGetMaterialTexture" );
+      }
+      ++m_sRefCount;
+   }
+
+   /**
+    * Decreases the reference counter and unloads the library if this was the
+    * last reference.
+    */
+   static void unload() {
+      assert( m_sRefCount > 0 );
+      --m_sRefCount;
+
+      if ( m_sRefCount == 0 ) {
+         m_sLibrary.unload();
+      }
+   }
+
+private:
+   // The binding magic is heavily inspired by the Derelict loading code.
+   struct Binder {
+   public:
+      static Binder opCall( void** functionPointerAddress ) {
+         Binder binder;
+         binder.m_functionPointerAddress = functionPointerAddress;
+         return binder;
+      }
+
+      void opCall( char* name ) {
+         *m_functionPointerAddress = m_sLibrary.getSymbol( name );
+      }
+
+   private:
+       void** m_functionPointerAddress;
+   }
+
+   template bind( Function ) {
+      static Binder bind( inout Function a ) {
+         Binder binder = Binder( cast( void** ) &a );
+         return binder;
+      }
+   }
+
+   /// Current number of references to the library.
+   static uint m_sRefCount;
+
+   /// Library handle.
+   static SharedLib m_sLibrary;
+}

port/dAssimp/assimp/material.d

@@ -0,0 +1,640 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Contains the material system which stores the imported material information.
+ */
+module assimp.material;
+
+import assimp.math;
+import assimp.types;
+
+extern ( C ) {
+   /**
+    * Default material names for meshes without UV coordinates.
+    */
+   const char* AI_DEFAULT_MATERIAL_NAME = "aiDefaultMat";
+
+   /**
+    * Default material names for meshes with UV coordinates.
+    */
+   const char* AI_DEFAULT_TEXTURED_MATERIAL_NAME = "TexturedDefaultMaterial";
+
+   /**
+    * Defines how the Nth texture of a specific type is combined with the
+    * result of all previous layers.
+    *
+    * Example (left: key, right: value):
+    * <pre> DiffColor0     - gray
+    * DiffTextureOp0 - aiTextureOpMultiply
+    * DiffTexture0   - tex1.png
+    * DiffTextureOp0 - aiTextureOpAdd
+    * DiffTexture1   - tex2.png</pre>
+    * Written as equation, the final diffuse term for a specific pixel would be:
+    * <pre>diffFinal = DiffColor0 * sampleTex( DiffTexture0, UV0 ) +
+    *     sampleTex( DiffTexture1, UV0 ) * diffContrib;</pre>
+    * where <code>diffContrib</code> is the intensity of the incoming light for
+    * that pixel.
+    */
+   enum aiTextureOp : uint {
+      /**
+       * <code>T = T1 * T2</code>
+       */
+      Multiply = 0x0,
+
+      /**
+       * <code>T = T1 + T2</code>
+       */
+      Add = 0x1,
+
+      /**
+       * <code>T = T1 - T2</code>
+       */
+      Subtract = 0x2,
+
+      /**
+       * <code>T = T1 / T2</code>
+       */
+      Divide = 0x3,
+
+      /**
+       * <code>T = ( T1 + T2 ) - ( T1 * T2 )</code>
+       */
+      SmoothAdd = 0x4,
+
+      /**
+       * <code>T = T1 + ( T2 - 0.5 )</code>
+       */
+      SignedAdd = 0x5
+   }
+
+   /**
+    * Defines how UV coordinates outside the <code>[0..1]</code> range are
+    * handled.
+    *
+    * Commonly refered to as 'wrapping mode'.
+    */
+   enum aiTextureMapMode : uint {
+      /**
+       * A texture coordinate <code>u | v</code> is translated to
+       * <code>(u%1) | (v%1)</code>.
+       */
+      Wrap = 0x0,
+
+      /**
+       * Texture coordinates are clamped to the nearest valid value.
+       */
+      Clamp = 0x1,
+
+      /**
+       * If the texture coordinates for a pixel are outside
+       * <code>[0..1]</code>, the texture is not applied to that pixel.
+       */
+      Decal = 0x3,
+
+      /**
+       * A texture coordinate <code>u | v</code> becomes
+       * <code>(u%1) | (v%1)</code> if <code>(u-(u%1))%2</code> is
+       * zero and <code>(1-(u%1)) | (1-(v%1))</code> otherwise.
+       */
+      Mirror = 0x2
+   }
+
+   /**
+    * Defines how the mapping coords for a texture are generated.
+    *
+    * Real-time applications typically require full UV coordinates, so the use of
+    * the <code>aiProcess.GenUVCoords</code> 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 <code>AI_MATKEY_MAPPING</code> property for more details.
+    */
+   enum aiTextureMapping : uint {
+      /**
+       * The mapping coordinates are taken from an UV channel.
+       *
+       * The <code>AI_MATKEY_UVSRC</code> key specifies from which (remember,
+       * meshes can have more than one UV channel).
+       */
+      UV = 0x0,
+
+      /**
+       * Spherical mapping.
+       */
+      SPHERE = 0x1,
+
+      /**
+       * Cylindrical mapping.
+       */
+      CYLINDER = 0x2,
+
+      /**
+       * Cubic mapping.
+       */
+      BOX = 0x3,
+
+      /**
+       * Planar mapping.
+       */
+      PLANE = 0x4,
+
+      /**
+       * Undefined mapping.
+       */
+      OTHER = 0x5
+   }
+
+   /**
+    * 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.
+    */
+   enum aiTextureType : uint {
+      /**
+       * No texture, but the value to be used for
+       * <code>aiMaterialProperty.mSemantic</code> for all material properties
+       * <em>not</em> related to textures.
+       */
+      NONE = 0x0,
+
+      /**
+       * The texture is combined with the result of the diffuse lighting
+       * equation.
+       */
+      DIFFUSE = 0x1,
+
+      /**
+       * The texture is combined with the result of the specular lighting
+       * equation.
+       */
+      SPECULAR = 0x2,
+
+      /**
+       * The texture is combined with the result of the ambient lighting
+       * equation.
+       */
+      AMBIENT = 0x3,
+
+      /**
+       * The texture is added to the result of the lighting calculation. It
+       * isn't influenced by incoming light.
+       */
+      EMISSIVE = 0x4,
+
+      /**
+       * The texture is a height map.
+       *
+       * By convention, higher grey-scale values stand for higher elevations
+       * from the base height.
+       */
+      HEIGHT = 0x5,
+
+      /**
+       * The texture is a (tangent space) normal-map.
+       *
+       * Again, there are several conventions for tangent-space normal maps.
+       * Assimp does (intentionally) not differenciate here.
+       */
+      NORMALS = 0x6,
+
+      /**
+       * 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.
+       */
+      SHININESS = 0x7,
+
+      /**
+       * The texture defines per-pixel opacity.
+       *
+       * Usually white means opaque and black means transparent.
+       */
+      OPACITY = 0x8,
+
+      /**
+       * Displacement texture.
+       *
+       * The exact purpose and format is application-dependent. Higher color
+       * values stand for higher vertex displacements.
+       */
+      DISPLACEMENT = 0x9,
+
+      /**
+       * Lightmap or ambient occlusion texture.
+       *
+       * Both lightmaps and dedicated ambient occlusion maps are covered by
+       * this material property. The texture contains a scaling value for the
+       * final color value of a pixel. Its intensity is not affected by
+       * incoming light.
+       */
+      LIGHTMAP = 0xA,
+
+      /**
+       * Reflection texture.
+       *
+       * Contains the color of a perfect mirror reflection. Rarely used, almost
+       * never for real-time applications.
+       */
+      REFLECTION = 0xB,
+
+      /**
+       * 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.
+       */
+      UNKNOWN = 0xC
+   }
+
+   /**
+    * 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.
+    */
+   enum aiShadingMode : uint {
+      /**
+       * Flat shading.
+       *
+       * Shading is done on per-face base diffuse only. Also known as
+       * »faceted shading«.
+       */
+      Flat = 0x1,
+
+      /**
+       * Simple Gouraud shading.
+       */
+      Gouraud =   0x2,
+
+      /**
+       * Phong-Shading.
+       */
+      Phong = 0x3,
+
+      /**
+       * Phong-Blinn-Shading.
+       */
+      Blinn = 0x4,
+
+      /**
+       * Per-pixel toon shading.
+       *
+       * Often referred to as »comic shading«.
+       */
+      Toon = 0x5,
+
+      /**
+       * Per-pixel Oren-Nayar shading.
+       *
+       * Extension to standard Lambertian shading, taking the roughness of the
+       * material into account.
+       */
+      OrenNayar = 0x6,
+
+      /**
+       * Per-pixel Minnaert shading.
+       *
+       * Extension to standard Lambertian shading, taking the "darkness" of the
+       * material into account.
+       */
+      Minnaert = 0x7,
+
+      /**
+       * Per-pixel Cook-Torrance shading.
+       *
+       * Special shader for metallic surfaces.
+       */
+      CookTorrance = 0x8,
+
+      /**
+       * No shading at all.
+       *
+       * Constant light influence of 1.
+       */
+      NoShading = 0x9,
+
+      /**
+       * Fresnel shading.
+       */
+      Fresnel = 0xa
+   }
+
+   /**
+    * 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 <code>AI_MATKEY_TEXFLAGS</code> property.
+    */
+   enum aiTextureFlags : uint {
+      /**
+       * The texture's color values have to be inverted (i.e. <code>1-n</code>
+       * component-wise).
+       */
+      Invert = 0x1,
+
+      /**
+       * Explicit request to the application to process the alpha channel of the
+       * texture.
+       *
+       * Mutually exclusive with <code>IgnoreAlpha</code>. 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.
+       */
+      UseAlpha = 0x2,
+
+      /**
+       * Explicit request to the application to ignore the alpha channel of the
+       * texture.
+       *
+       * Mutually exclusive with <code>UseAlpha</code>.
+       */
+      IgnoreAlpha = 0x4
+   }
+
+
+   /**
+    * Defines alpha-blend flags.
+    *
+    * If you're familiar with OpenGL or D3D, these flags aren't new to you.
+    * They define how the final color value of a pixel is computed, based on
+    * the previous color at that pixel and the new color value from the
+    * material.
+    *
+    * The basic blending formula is
+    * <code>SourceColor * SourceBlend + DestColor * DestBlend</code>,
+    * where <code>DestColor</code> is the previous color in the framebuffer at
+    * this position and <code>SourceColor</code> is the material color before
+    * the transparency calculation.
+    *
+    * This corresponds to the <code>AI_MATKEY_BLEND_FUNC</code> property.
+    */
+   enum aiBlendMode :uint {
+      /**
+       * Formula:
+       * <code>SourceColor * SourceAlpha + DestColor * (1 - SourceAlpha)</code>
+       */
+      Default = 0x0,
+
+      /**
+       * Additive blending.
+       *
+       * Formula: <code>SourceColor*1 + DestColor*1</code>
+       */
+      Additive = 0x1
+   }
+
+   /**
+    * Defines how an UV channel is transformed.
+    *
+    * This is just a helper structure for the <code>AI_MATKEY_UVTRANSFORM</code>
+    * key. See its documentation for more details.
+    */
+   struct aiUVTransform {
+   align ( 1 ) :
+      /**
+       * Translation on the u and v axes.
+       *
+       * The default value is (0|0).
+       */
+      aiVector2D mTranslation;
+
+      /**
+       * Scaling on the u and v axes.
+       *
+       * The default value is (1|1).
+       */
+      aiVector2D mScaling;
+
+      /**
+       * Rotation - in counter-clockwise direction.
+       *
+       * The rotation angle is specified in radians. The rotation center is
+       * 0.5|0.5. The default value is 0.
+       */
+      float mRotation;
+   }
+
+   /**
+    * A very primitive RTTI system to store the data type of a material
+    * property.
+    */
+   enum aiPropertyTypeInfo : uint {
+      /**
+       * Array of single-precision (32 bit) floats.
+       *
+       * It is possible to use <code>aiGetMaterialInteger[Array]()</code> to
+       * query properties stored in floating-point format. The material system
+       * performs the type conversion automatically.
+       */
+      Float = 0x1,
+
+      /**
+       * aiString property.
+       *
+       * Arrays of strings aren't possible, <code>aiGetMaterialString()</code>
+       * must be used to query a string property.
+       */
+      String = 0x3,
+
+      /**
+       * Array of (32 bit) integers.
+       *
+       * It is possible to use <code>aiGetMaterialFloat[Array]()</code> to
+       * query properties stored in integer format. The material system
+       * performs the type conversion automatically.
+       */
+      Integer = 0x4,
+
+      /**
+       * Simple binary buffer, content undefined. Not convertible to anything.
+       */
+      Buffer = 0x5
+   }
+
+   /**
+    * Data structure for a single material property.
+    *
+    * As an user, you'll probably never need to deal with this data structure.
+    * Just use the provided <code>aiGetMaterialXXX()</code> functions to query
+    * material properties easily. Processing them manually is faster, but it is
+    * not the recommended way. It isn't worth the effort.
+    *
+    * Material property names follow a simple scheme:
+    *
+    * <code>$[name]</code>: A public property, there must be a corresponding
+    * AI_MATKEY_XXX constant.
+    *
+    * <code>?[name]</code>: Also public, but ignored by the
+    * <code>aiProcess.RemoveRedundantMaterials</code> post-processing step.
+    *
+    * <code>~[name]</code>: A temporary property for internal use.
+    */
+   struct aiMaterialProperty {
+      /**
+       * Specifies the name of the property (key).
+       *
+       * Keys are generally case insensitive.
+       */
+      aiString mKey;
+
+      /**
+       * For texture properties, this specifies the exact usage semantic.
+       *
+       * For non-texture properties, this member is always 0 (or rather
+       * <code>aiTextureType.NONE</code>).
+       */
+      uint mSemantic;
+
+      /**
+       * For texture properties, this specifies the index of the texture.
+       *
+       * For non-texture properties, this member is always 0.
+       */
+      uint mIndex;
+
+      /**
+       * Size of the buffer <code>mData</code> is pointing to (in bytes).
+       *
+       * This value may not be 0.
+       */
+      uint mDataLength;
+
+      /**
+       * Type information for the property.
+       *
+       * Defines the data layout inside the data buffer. This is used by the
+       * library internally to perform debug checks and to utilize proper type
+       * conversions.
+       */
+      aiPropertyTypeInfo mType;
+
+      /**
+       * Binary buffer to hold the property's value.
+       *
+       * The size of the buffer is always <code>mDataLength</code>.
+       */
+      char* mData;
+   }
+
+   /**
+    * Data structure for a material
+    *
+    * Material data is stored using a key-value structure. A single key-value
+    * pair is called a <em>material property</em>. The properties can be
+    * queried using the <code>aiMaterialGetXXX</code> family of functions. The
+    * library defines a set of standard keys (AI_MATKEY_XXX).
+    */
+   struct aiMaterial {
+      /**
+       * List of all material properties loaded.
+       */
+      aiMaterialProperty** mProperties;
+
+      /**
+       * Number of properties loaded.
+       */
+      uint mNumProperties;
+      uint mNumAllocated; /// ditto
+   }
+
+   /**
+    * Standard material property keys. Always pass 0 for texture type and index
+    * when querying these keys.
+    */
+   const char* AI_MATKEY_NAME = "?mat.name";
+   const char* AI_MATKEY_TWOSIDED = "$mat.twosided"; /// ditto
+   const char* AI_MATKEY_SHADING_MODEL = "$mat.shadingm"; /// ditto
+   const char* AI_MATKEY_ENABLE_WIREFRAME = "$mat.wireframe"; /// ditto
+   const char* AI_MATKEY_BLEND_FUNC = "$mat.blend"; /// ditto
+   const char* AI_MATKEY_OPACITY = "$mat.opacity"; /// ditto
+   const char* AI_MATKEY_BUMPSCALING = "$mat.bumpscaling"; /// ditto
+   const char* AI_MATKEY_SHININESS = "$mat.shininess"; /// ditto
+   const char* AI_MATKEY_SHININESS_STRENGTH = "$mat.shinpercent"; /// ditto
+   const char* AI_MATKEY_REFRACTI = "$mat.refracti"; /// ditto
+   const char* AI_MATKEY_COLOR_DIFFUSE = "$clr.diffuse"; /// ditto
+   const char* AI_MATKEY_COLOR_AMBIENT = "$clr.ambient"; /// ditto
+   const char* AI_MATKEY_COLOR_SPECULAR = "$clr.specular"; /// ditto
+   const char* AI_MATKEY_COLOR_EMISSIVE = "$clr.emissive"; /// ditto
+   const char* AI_MATKEY_COLOR_TRANSPARENT = "$clr.transparent"; /// ditto
+   const char* AI_MATKEY_COLOR_REFLECTIVE = "$clr.reflective"; /// ditto
+   const char* AI_MATKEY_GLOBAL_BACKGROUND_IMAGE = "?bg.global"; /// ditto
+
+   /**
+    * Texture material property keys. Do not forget to specify texture type and
+    * index for these keys.
+    */
+   const char* AI_MATKEY_TEXTURE = "$tex.file";
+   const char* AI_MATKEY_UVWSRC = "$tex.uvwsrc"; /// ditto
+   const char* AI_MATKEY_TEXOP = "$tex.op"; /// ditto
+   const char* AI_MATKEY_MAPPING = "$tex.mapping"; /// ditto
+   const char* AI_MATKEY_TEXBLEND = "$tex.blend"; /// ditto
+   const char* AI_MATKEY_MAPPINGMODE_U = "$tex.mapmodeu"; /// ditto
+   const char* AI_MATKEY_MAPPINGMODE_V = "$tex.mapmodev"; /// ditto
+   const char* AI_MATKEY_TEXMAP_AXIS = "$tex.mapaxis"; /// ditto
+   const char* AI_MATKEY_UVTRANSFORM = "$tex.uvtrafo"; /// ditto
+   const char* AI_MATKEY_TEXFLAGS = "$tex.flags"; /// ditto
+}

port/dAssimp/assimp/math.d

@@ -0,0 +1,155 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Mathematical structures in which the imported data is stored.
+ */
+module assimp.math;
+
+extern( C ) {
+   /**
+    * Represents a two-dimensional vector.
+    */
+   struct aiVector2D {
+   align ( 1 ):
+      float x, y;
+   }
+
+   /**
+    * Represents a three-dimensional vector.
+    */
+   struct aiVector3D {
+   align ( 1 ):
+      float x, y, z;
+   }
+
+   /**
+    * Represents a quaternion.
+    */
+   struct aiQuaternion {
+      float w, x, y, z;
+   }
+
+   /**
+    * Represents a row-major 3x3 matrix
+    *
+    * There is much confusion about matrix layouts (colum vs. row order). This
+    * is <em>always</em> a row-major matrix, even when using the
+    * <code>ConvertToLeftHanded</code> post processing step.
+    */
+   struct aiMatrix3x3 {
+      float a1, a2, a3;
+      float b1, b2, b3;
+      float c1, c2, c3;
+   }
+
+   /**
+    * Represents a row-major 3x3 matrix
+    *
+    * There is much confusion about matrix layouts (colum vs. row order). This
+    * is <em>always</em> a row-major matrix, even when using the
+    * <code>ConvertToLeftHanded</code> post processing step.
+    */
+   struct aiMatrix4x4 {
+   align ( 1 ):
+      float a1, a2, a3, a4;
+      float b1, b2, b3, b4;
+      float c1, c2, c3, c4;
+      float d1, d2, d3, d4;
+   }
+
+   /**
+    * Represents a plane in a three-dimensional, euclidean space
+    */
+   struct aiPlane {
+   align ( 1 ):
+      /**
+       * Coefficients of the plane equation (<code>ax + by + cz = d</code>).
+       */
+      float a;
+      float b; /// ditto
+      float c; /// ditto
+      float d; /// ditto
+   }
+
+   /**
+    * Represents a ray.
+    */
+   struct aiRay {
+   align ( 1 ):
+      /**
+       * Origin of the ray.
+       */
+      aiVector3D pos;
+
+      /**
+       * Direction of the ray.
+       */
+      aiVector3D dir;
+   }
+
+   /**
+    * Represents a color in RGB space.
+    */
+   struct aiColor3D {
+   align ( 1 ):
+      /**
+       * Red, green and blue values.
+       */
+      float r;
+      float g; /// ditto
+      float b; /// ditto
+   }
+
+   /**
+    * Represents a color in RGB space including an alpha component.
+    */
+   struct aiColor4D {
+   align ( 1 ):
+      /**
+       * Red, green, blue and alpha values.
+       */
+      float r;
+      float g; /// ditto
+      float b; /// ditto
+      float a; /// ditto
+   }
+}

port/dAssimp/assimp/mesh.d

@@ -0,0 +1,367 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Contains the data structures in which the imported geometry is returned by
+ * Assimp.
+ */
+module assimp.mesh;
+
+import assimp.math;
+import assimp.types;
+
+extern ( C ) {
+   /**
+    * A single face in a mesh, referring to multiple vertices.
+    *
+    * If <code>mNumIndices</code> is 3, we call the face <em>triangle</em>, for
+    * for <code>mNumIndices > 3</code> it's called <em>polygon</em>.
+    *
+    * <code>aiMesh.mPrimitiveTypes</code> can be queried to quickly examine
+    * which types of primitive are actually present in a mesh. The
+    * <code>aiProcess.SortByPType</code> flag post-processing step splits
+    * meshes containing different primitive types (e.g. lines and triangles) in
+    * several "clean" submeshes.
+    *
+    * Furthermore, there is a configuration option
+    * (<code>AI_CONFIG_PP_SBP_REMOVE</code>) to force <code>SortByPType</code>
+    * to completely remove specific kinds of primitives from the imported scene.
+    * In many cases you'll probably want to set this setting to
+    * <code>aiPrimitiveType.LINE | aiPrimitiveType.POINT</code>. Together with
+    * the <code>aiProcess.Triangulate</code> flag you can then be sure that
+    * <code>mNumIndices</code> is always 3.
+    */
+   struct aiFace {
+      /**
+       * Number of indices defining this face (3 for a triangle, >3 for a
+       * polygon).
+       */
+      uint mNumIndices;
+
+      /**
+       * Array of the indicies defining the face.
+       *
+       * The size is given in <code>mNumIndices</code>.
+       */
+      uint* mIndices;
+   }
+
+   /**
+    * A single influence of a bone on a vertex.
+    */
+   struct aiVertexWeight {
+      /**
+       * Index of the vertex which is influenced by the bone.
+       */
+      uint mVertexId;
+
+      /**
+       * The strength of the influence in the range <code>[0..1]</code>.
+       *
+       * The influence from all bones at one vertex sums up to 1.
+       */
+      float mWeight;
+   }
+
+   /**
+    * 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.
+    */
+   struct aiBone {
+      /**
+       * The name of the bone.
+       */
+      aiString mName;
+
+      /**
+       * The number of vertices affected by this bone.
+       */
+      uint mNumWeights;
+
+      /**
+       * The vertices affected by this bone.
+       *
+       * This array is <code>mNumWeights</code> entries in size.
+       */
+      aiVertexWeight* mWeights;
+
+      /**
+       * Matrix that transforms from mesh space to bone space (in the bind
+       * pose).
+       */
+      aiMatrix4x4 mOffsetMatrix;
+   }
+
+   /**
+    * Maximum number of vertex color sets per mesh.
+    *
+    * Normally: Diffuse, specular, ambient and emissive. However, one could use
+    * the vertex color sets for any other purpose, too.
+    *
+    * Note: Some internal structures expect (and assert) this value to be at
+    *    least 4. For the moment it is absolutely safe to assume that this will
+    *    not change.
+    */
+   const uint AI_MAX_NUMBER_OF_COLOR_SETS = 0x4;
+
+   /**
+    * Maximum number of texture coord sets (UV(W) channels) per mesh
+    *
+    * The material system uses the <code>AI_MATKEY_UVWSRC_XXX</code> keys to
+    * specify which UVW channel serves as data source for a texture.
+    *
+    * Note: Some internal structures expect (and assert) this value to be at
+    *    least 4. For the moment it is absolutely safe to assume that this will
+    *    not change.
+    */
+   const uint AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x4;
+
+   /**
+    * Enumerates the types of geometric primitives supported by Assimp.
+    *
+    * See: <code>aiFace</code>, <code>aiProcess.SortByPType</code>,
+    *    <code>aiProcess.Triangulate</code>,
+    *    <code>AI_CONFIG_PP_SBP_REMOVE</code>.
+    */
+   enum aiPrimitiveType : uint {
+      /** A point primitive.
+       *
+       * This is just a single vertex in the virtual world,
+       * <code>aiFace</code> contains just one index for such a primitive.
+       */
+      POINT = 0x1,
+
+      /** A line primitive.
+       *
+       * This is a line defined through a start and an end position.
+       * <code>aiFace</code> contains exactly two indices for such a primitive.
+       */
+      LINE = 0x2,
+
+      /** A triangular primitive.
+       *
+       * A triangle consists of three indices.
+       */
+      TRIANGLE = 0x4,
+
+      /** A higher-level polygon with more than 3 edges.
+       *
+       * A triangle is a polygon, but in this context, polygon means
+       * "all polygons that are not triangles". The <code>Triangulate</code>
+       * post processing step is provided for your convinience, it splits all
+       * polygons in triangles (which are much easier to handle).
+       */
+      POLYGON = 0x8
+   }
+
+   // Note: The AI_PRIMITIVE_TYPE_FOR_N_INDICES(n) macro from the C headers is
+   // missing since there is probably not much use for it when just reading
+   // scene files.
+
+   /**
+    * A mesh represents a geometry or model with a single material.
+    *
+    * It usually consists of a number of vertices and a series
+    * 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.
+    *
+    * A mesh uses only a single material which is referenced by a material ID.
+    *
+    * Note: The <code>mPositions</code> member is usually not optional.
+    *    However, vertex positions <em>could</em> be missing if the
+    *    <code>AI_SCENE_FLAGS_INCOMPLETE</code> flag is set in
+    *    <code>aiScene.mFlags</code>.
+    */
+   struct aiMesh {
+      /**
+       * Bitwise combination of <code>aiPrimitiveType</code> members.
+       *
+       * This specifies which types of primitives are present in the mesh.
+       * The <code>SortByPrimitiveType</code> post processing step can be used
+       * to make sure the output meshes consist of one primitive type each.
+       */
+      uint mPrimitiveTypes;
+
+      /**
+       * The number of vertices in this mesh.
+       *
+       * This is also the size of all of the per-vertex data arrays.
+       */
+      uint mNumVertices;
+
+      /**
+       * The number of primitives (triangles, polygons, lines) in this  mesh.
+       * This is also the size of the <code>mFaces</code> array.
+       */
+      uint mNumFaces;
+
+      /**
+       * Vertex positions.
+       *
+       * This array is always present in a mesh. The array is
+       * <code>mNumVertices</code> in size.
+       */
+      aiVector3D* mVertices;
+
+      /**
+       * Vertex normals.
+       *
+       * The array contains normalized vectors, null if not present.
+       * The array is <code>mNumVertices</code> 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 <code>QNAN</code>.
+       *
+       * 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.
+       */
+      aiVector3D* mNormals;
+
+      /**
+       * 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 <code>mNumVertices</code> 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
+       * <code>QNAN</code>.
+       *
+       * Note: If the mesh contains tangents, it automatically also contains
+       *    bitangents (the bitangent is just the cross product of tangent and
+       *    normal vectors).
+       */
+      aiVector3D* mTangents;
+
+      /**
+       * 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 <code>mNumVertices</code> in size.
+       *
+       * Note: If the mesh contains tangents, it automatically also contains
+       *    bitangents.
+       */
+      aiVector3D* mBitangents;
+
+      /**
+       * Vertex color sets.
+       *
+       * A mesh may contain 0 to <code>AI_MAX_NUMBER_OF_COLOR_SETS</code>
+       * vertex colors per vertex. null if not present.
+       *
+       * Each array is <code>mNumVertices</code> in size if present.
+       */
+      aiColor4D* mColors[ AI_MAX_NUMBER_OF_COLOR_SETS ];
+
+      /**
+       * Vertex texture coords, also known as UV channels.
+       * A mesh may contain 0 to <code>AI_MAX_NUMBER_OF_TEXTURECOORDS</code>
+       * per vertex. null if not present.
+       *
+       * Each array is <code>mNumVertices</code> in size.
+       */
+      aiVector3D* mTextureCoords[ 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 <code>n</code>, the
+       * component <code>p.z</code> of <code>mTextureCoords[n][p]</code> is set
+       * to 0. If the value is 1 for a given channel, <code>p.y</code> is set
+       * to 0, too. If this value is 0, 2 should be assumed.
+       *
+       * Note: 4D coords are not supported.
+       */
+      uint mNumUVComponents[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
+
+      /**
+       * The faces the mesh is contstructed from.
+       *
+       * Each face referrs to a number of vertices by their indices.
+       * This array is always present in a mesh, its size is given
+       * in <code>mNumFaces</code>. If the
+       * <code>AI_SCENE_FLAGS_NON_VERBOSE_FORMAT</code> is <em>not</em> set,
+       * each face references an unique set of vertices.
+       */
+      aiFace* mFaces;
+
+      /**
+       * The number of bones this mesh contains.
+       *
+       * Can be 0, in which case the <code>mBones</code> array is null.
+       */
+      uint mNumBones;
+
+      /**
+       * 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.
+       */
+      aiBone** mBones;
+
+      /**
+       * 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.
+       */
+      uint mMaterialIndex;
+   }
+}

port/dAssimp/assimp/postprocess.d

@@ -0,0 +1,588 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Definitions for import post processing steps.
+ */
+module assimp.postprocess;
+
+extern ( C ) {
+   /**
+    * Defines the flags for all possible post processing steps.
+    *
+    * See: <code>aiImportFile</code>, <code>aiImportFileEx</code>
+    */
+   enum aiPostProcessSteps {
+      /**
+       * 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 is a
+       * config setting, <code>AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE</code>,
+       * which allows you to specify a maximum smoothing angle for the
+       * algorithm. However, usually you will want to use the default value.
+       */
+      CalcTangentSpace = 0x1,
+
+      /**
+       * 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 will just waste
+       * rendering time. <em>If this flag is not specified</em>, no vertices
+       * are referenced by more than one face and <em>no index buffer is
+       * required</em> for rendering.
+       */
+      JoinIdenticalVertices = 0x2,
+
+      /**
+       * 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 will probably want to consider this flag if you use Direct3D for
+       * rendering. The <code>ConvertToLeftHanded</code> flag supersedes this
+       * setting and bundles all conversions typically required for D3D-based
+       * applications.
+       */
+      MakeLeftHanded = 0x4,
+
+      /**
+       * 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 <em>not</em> modified!.
+       *
+       * If you want »triangles only« with no other kinds of primitives,
+       * specify both <code>Triangulate</code> and <code>SortByPType</code> and
+       * ignore all point and line meshes when you process Assimp's output.
+       */
+      Triangulate = 0x8,
+
+      /**
+       * 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, <code>AI_CONFIG_PP_RVC_FLAGS</code>. 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 since the corresponding steps don't recompute them
+       * if they have already been loaded from the source asset.
+       *
+       * This flag is a poor one, mainly because its purpose is usually
+       * misunderstood. Consider the following case: a 3d model has been exported
+       * from a CAD app, it has per-face vertex colors. Because of the vertex
+       * colors (which are not even used by most apps),
+       * <code>JoinIdenticalVertices</code> cannot join vertices at the same
+       * position. By using this step, unneeded components are excluded as
+       * early as possible thus opening more room for internal optimzations.
+       */
+      RemoveComponent = 0x10,
+
+      /**
+       * 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 are 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. <code>JoinIdenticalVertices</code>
+       * is <em>useless</em> then.
+       *
+       * This flag may not be specified together with
+       * <code>GenSmoothNormals</code>.
+       */
+      GenNormals = 0x20,
+
+      /**
+       * 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 are usually already there.
+       *
+       * There is a configuration option,
+       * <code>AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE</code> which allows you to
+       * specify an angle maximum for the normal smoothing algorithm. Normals
+       * exceeding this limit are not smoothed, resulting in a »hard« seam
+       * between two faces. Using a decent angle here (e.g. 80°) results in
+       * very good visual appearance.
+       */
+      GenSmoothNormals = 0x40,
+
+      /**
+       * 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
+       * <code>AI_CONFIG_PP_SLM_VERTEX_LIMIT</code> and
+       * <code>AI_CONFIG_PP_SLM_TRIANGLE_LIMIT</code> settings. The default
+       * values are <code>AI_SLM_DEFAULT_MAX_VERTICES</code> and
+       * <code>AI_SLM_DEFAULT_MAX_TRIANGLES</code>.
+       *
+       * 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.
+       */
+      SplitLargeMeshes = 0x80,
+
+      /**
+       * 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 <em>can</em> 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.
+       */
+      PreTransformVertices = 0x100,
+
+      /**
+       * 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 (<code>AI_LMW_MAX_WEIGHTS</code>),
+       * but you can use the <code>#AI_CONFIG_PP_LBW_MAX_WEIGHTS</code> 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.
+       */
+      LimitBoneWeights = 0x200,
+
+      /**
+       * 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 <em>all</em>
+       * inconsistencies in the data structure.
+       *
+       * Plugin developers are recommended to use it to debug their loaders.
+       *
+       * There are two types of validation failures:
+       * <ul>
+       * <li>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, see <code>aiGetErrorString()</code> for the
+       *    error message.</li>
+       * <li>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, <code>AI_SCENE_FLAGS_VALIDATION_WARNING</code> is
+       *   set in <code>aiScene::mFlags</code></li>
+       * </ul>
+       *
+       * This post-processing step is not time-consuming. It's use is not
+       * compulsory, but recommended.
+       */
+      ValidateDataStructure = 0x400,
+
+      /**
+       * 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
+       * <tt>http://www.cs.princeton.edu/gfx/pubs/Sander_2007_%3ETR/tipsy.pdf</tt>).
+       *
+       * If you intend to render huge models in hardware, this step might
+       * be of interest for you. The <code>AI_CONFIG_PP_ICL_PTCACHE_SIZE</code>
+       * config setting can be used to fine-tune the cache optimization.
+       */
+      ImproveCacheLocality = 0x800,
+
+      /**
+       * Searches for redundant/unreferenced materials and removes them.
+       *
+       * This is especially useful in combination with the
+       * <code>PretransformVertices</code> and <code>OptimizeMeshes</code>
+       * 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 are passing additional information through the
+       * content pipeline (probably using »magic« material names), don't
+       * specify this flag. Alternatively take a look at the
+       * <code>AI_CONFIG_PP_RRM_EXCLUDE_LIST</code> setting.
+       */
+      RemoveRedundantMaterials = 0x1000,
+
+      /**
+       * This step tries to determine which meshes have normal vectors that are
+       * acing inwards.
+       *
+       * The algorithm is simple but effective: The bounding box of all
+       * vertices and 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.
+       */
+      FixInfacingNormals = 0x2000,
+
+      /**
+       * 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 <code>aiMesh.mPrimitiveTypes</code>.
+       * This is especially useful for real-time rendering where point and line
+       * primitives are often ignored or rendered separately.
+       *
+       * You can use the <code>AI_CONFIG_PP_SBP_REMOVE</code> 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.
+       */
+      SortByPType = 0x8000,
+
+      /**
+       * 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:
+       *
+       * <b>1.</b> (if you support lines and points for rendering but don't
+       *    want the degenerates)
+       * <ul>
+       *   <li>Specify the <code>FindDegenerates</code> flag.</li>
+       *   <li>Set the <code>AI_CONFIG_PP_FD_REMOVE</code> 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.</li>
+       * </ul>
+       *
+       * <b>2.</b>(if you don't support lines and points at all ...)
+       * <ul>
+       *   <li>Specify the <code>FindDegenerates</code> flag.</li>
+       *   <li>Specify the <code>SortByPType</code> flag. This moves line and
+       *      point primitives to separate meshes.</li>
+       *   <li>Set the <code>AI_CONFIG_PP_SBP_REMOVE</codet> option to
+       *      <code>aiPrimitiveType_POINTS | aiPrimitiveType_LINES</code>
+       *      to cause SortByPType to reject point and line meshes from the
+       *      scene.</li>
+       * </ul>
+       *
+       * Note: Degenerated polygons are not necessarily bad 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.
+       */
+      FindDegenerates = 0x10000,
+
+      /**
+       * 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.
+       */
+      FindInvalidData = 0x20000,
+
+      /**
+       * This step converts non-UV mappings (such as spherical or cylindrical
+       * mapping) to proper texture coordinate channels.
+       *
+       * Most applications will support UV mapping only, so you will probably
+       * want to specify this step in every case. Note 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
+       *    <code>AI_MATKEY_MAPPING</code> material property in order to
+       *    display all assets properly.
+       */
+      GenUVCoords = 0x40000,
+
+      /**
+       * This step applies per-texture UV transformations and bakes them to
+       * stand-alone vtexture coordinate channelss.
+       *
+       * UV transformations are specified per-texture – see the
+       * <code>AI_MATKEY_UVTRANSFORM</code> 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.
+       */
+      TransformUVCoords = 0x80000,
+
+      /**
+       * 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. Its 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
+       * <em>not</em> joined, although this is planned for future versions.
+       */
+      FindInstances = 0x100000,
+
+      /**
+       * 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 <code>OptimizeGraph</code>, if possible. The flag is
+       * fully compatible with both <code>SplitLargeMeshes</code> and
+       * <code>SortByPType</code>.
+       */
+      OptimizeMeshes = 0x200000,
+
+      /**
+       * 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
+       * <code>AI_CONFIG_PP_OG_EXCLUDE_LIST</code> 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
+       * note 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 <code>OptimizeMeshes</code> for
+       * best results.
+       *
+       * Note: »Crappy« scenes with thousands of extremely small meshes packed
+       *    in deeply nested nodes exist for almost all file formats.
+       *    <code>OptimizeMeshes</code> in combination with
+       *    <code>OptimizeGraph</code> usually fixes them all and makes them
+       *    renderable.
+       */
+      OptimizeGraph  = 0x400000,
+
+      /** This step flips all UV coordinates along the y-axis and adjusts
+       * material settings and bitangents accordingly.
+       *
+       * Output UV coordinate system:
+       * <pre> 0y|0y ---------- 1x|0y
+       * |                 |
+       * |                 |
+       * |                 |
+       * 0x|1y ---------- 1x|1y</pre>
+       * You'll probably want to consider this flag if you use Direct3D for
+       * rendering. The <code>AI_PROCESS_CONVERT_TO_LEFT_HANDED</code> flag
+       * supersedes this setting and bundles all conversions typically required
+       * for D3D-based applications.
+      */
+      FlipUVs = 0x800000,
+
+      /**
+       * This step adjusts the output face winding order to be clockwise.
+       *
+       * The default face winding order is counter clockwise.
+       *
+       * Output face order:
+       * <pre>       x2
+       *
+       *                         x0
+       *  x1</pre>
+       */
+      FlipWindingOrder  = 0x1000000
+   }
+
+   /**
+    * Abbrevation for convenience.
+    */
+   alias aiPostProcessSteps aiProcess;
+
+   /**
+    * Shortcut flag for Direct3D-based applications.
+    *
+    * Combines the <code>MakeLeftHanded</code>, <code>FlipUVs</code> and
+    * <code>FlipWindingOrder</code> flags. The output data matches Direct3D's
+    * conventions: left-handed geometry, upper-left origin for UV coordinates
+    * and clockwise face order, suitable for CCW culling.
+    */
+   const aiPostProcessSteps AI_PROCESS_CONVERT_TO_LEFT_HANDED =
+      aiProcess.MakeLeftHanded |
+      aiProcess.FlipUVs |
+      aiProcess.FlipWindingOrder;
+
+   /**
+    * Default postprocess configuration optimizing the data for real-time rendering.
+    *
+    * Applications would want to use this preset to load models on end-user
+    * PCs, maybe for direct use in game.
+    *
+    * If you're using DirectX, don't forget to combine this value with
+    * the <code>ConvertToLeftHanded</code> step. If you don't support UV
+    * transformations in your application, apply the
+    * <code>TransformUVCoords</code> step, too.
+    *
+    * Note: Please take the time to read the doc for the steps enabled by this
+    *   preset. Some of them offer further configurable properties, some of
+    *   them might not be of use for you so it might be better to not specify
+    *   them.
+    */
+   const aiPostProcessSteps AI_PROCESS_PRESET_TARGET_REALTIME_FAST =
+      aiProcess.CalcTangentSpace |
+      aiProcess.GenNormals |
+      aiProcess.JoinIdenticalVertices |
+      aiProcess.Triangulate |
+      aiProcess.GenUVCoords |
+      aiProcess.SortByPType;
+
+    /**
+     * Default postprocess configuration optimizing the data for real-time
+     * rendering.
+     *
+     * Unlike <code>AI_PROCESS_PRESET_TARGET_REALTIME_FAST</code>, this
+     * configuration performs some extra optimizations to improve rendering
+     * speed and to minimize memory usage. It could be a good choice for a
+     * level editor environment where import speed is not so important.
+     *
+     * If you're using DirectX, don't forget to combine this value with
+     * the <code>ConvertToLeftHanded</code> step. If you don't support UV
+     * transformations in your application, apply the
+     * <code>TransformUVCoords</code> step, too.
+     *
+     * Note: Please take the time to read the doc for the steps enabled by this
+     *   preset. Some of them offer further configurable properties, some of
+     *   them might not be of use for you so it might be better to not specify
+     *   them.
+     */
+   const aiPostProcessSteps AI_PROCESS_PRESET_TARGET_REALTIME_QUALITY =
+      aiProcess.CalcTangentSpace |
+      aiProcess.GenSmoothNormals |
+      aiProcess.JoinIdenticalVertices |
+      aiProcess.ImproveCacheLocality |
+      aiProcess.LimitBoneWeights |
+      aiProcess.RemoveRedundantMaterials |
+      aiProcess.SplitLargeMeshes |
+      aiProcess.Triangulate |
+      aiProcess.GenUVCoords |
+      aiProcess.SortByPType |
+      aiProcess.FindDegenerates |
+      aiProcess.FindInvalidData;
+
+    /**
+     * Default postprocess configuration optimizing the data for real-time
+     * rendering.
+     *
+     * This preset enables almost every optimization step to achieve perfectly
+     * optimized data. It's your choice for level editor environments where
+     * import speed is not important.
+     *
+     * If you're using DirectX, don't forget to combine this value with
+     * the <code>ConvertToLeftHanded</code> step. If you don't support UV
+     * transformations in your application, apply the
+     * <code>TransformUVCoords</code> step, too.
+     *
+     * Note: Please take the time to read the doc for the steps enabled by this
+     *   preset. Some of them offer further configurable properties, some of
+     *   them might not be of use for you so it might be better to not specify
+     *   them.
+     */
+   const aiPostProcessSteps AI_PROCESS_PRESET_TARGET_REALTIME_MAX_QUALITY =
+      AI_PROCESS_PRESET_TARGET_REALTIME_QUALITY |
+      aiProcess.FindInstances |
+      aiProcess.ValidateDataStructure |
+      aiProcess.OptimizeMeshes;
+}

port/dAssimp/assimp/scene.d

@@ -0,0 +1,306 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Contains the data structures which store the hierarchy fo the imported data.
+ */
+module assimp.scene;
+
+import assimp.animation;
+import assimp.camera;
+import assimp.light;
+import assimp.math;
+import assimp.mesh;
+import assimp.material;
+import assimp.texture;
+import assimp.types;
+
+extern ( C ) {
+   /**
+    * 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 with
+    * no childs.
+    */
+   struct aiNode {
+      /**
+       * 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 animations are usually named.
+       * Multiple nodes may have the same name, but nodes which are accessed
+       * by bones (see <code>aiBone</code> and <code>aiMesh.mBones</code>)
+       * <em>must</em> be unique.
+       *
+       * Cameras and lights are assigned to a specific node name – if there are
+       * multiple nodes with this name, they are assigned to each of them.
+       *
+       * There are no limitations regarding the characters contained in this
+       * string. You should be able to handle stuff like whitespace, tabs,
+       * linefeeds, quotation marks, ampersands, …
+       */
+      aiString mName;
+
+      /**
+       * The transformation relative to the node's parent.
+       */
+      aiMatrix4x4 mTransformation;
+
+      /**
+       * Parent node.
+       *
+       * null if this node is the root node.
+       */
+      aiNode* mParent;
+
+      /**
+       * The number of child nodes of this node.
+       */
+      uint mNumChildren;
+
+      /**
+       * The child nodes of this node.
+       *
+       * null if <code>mNumChildren</code> is 0.
+       */
+      aiNode** mChildren;
+
+      /**
+       * The number of meshes of this node.
+       */
+      int mNumMeshes;
+
+      /**
+       * The meshes of this node.
+       *
+       * Each entry is an index for <code>aiScene.mMeshes</code>.
+       */
+      uint* mMeshes;
+   }
+
+   /**
+    * Flags which are combinated in <code>aiScene.mFlags</code> to store
+    * auxiliary information about the imported scene.
+    */
+   enum aiSceneFlags : uint {
+      /**
+       * Specifies that the scene data structure that was imported is not
+       * complete.
+       *
+       * This flag bypasses some internal validations and allows the import of
+       * animation skeletons, material libraries or camera animation paths
+       * using Assimp. Most applications won't support such data.
+       */
+      INCOMPLETE = 0x1,
+
+      /**
+       * This flag is set by the validation post-processing step
+       * (<code>aiProcess.ValidateDS</code>) if the validation was successful.
+       *
+       * In a validated scene you can be sure that any cross references in the
+       * data structure (e.g. vertex indices) are valid.
+       */
+      VALIDATED = 0x2,
+
+      /**
+       * This flag is set by the validation post-processing step
+       * (<code>aiProcess.ValidateDS</code>) if the validation is successful
+       * but some issues have been found.
+       *
+       * This can for example mean that a texture that does not exist is
+       * referenced by a material or that the bone weights for a vertex don't
+       * sum to 1. In most cases you should still be able to use the import.
+       *
+       * This flag could be useful for applications which don't capture
+       * Assimp's log output.
+       */
+      VALIDATION_WARNING = 0x4,
+
+      /**
+       * This flag is currently only set by the
+       * <code>aiProcess.JoinIdenticalVertices</code> post-processing step. It
+       * indicates that the vertices of the output meshes aren't in the
+       * internal verbose format anymore. In the verbose format all vertices
+       * are unique, no vertex is ever referenced by more than one face.
+       */
+      NON_VERBOSE_FORMAT = 0x8,
+
+      /**
+       * Denotes pure height-map terrain data. Pure terrains usually consist of
+       * quads, sometimes triangles, in a regular grid. The x,y coordinates of
+       * all vertex positions refer to the x,y coordinates on the terrain
+       * height map, the z-axis stores the elevation at a specific point.
+       *
+       * TER (Terragen) and HMP (3D Game Studio) are height map formats.
+       *
+       * Note: Assimp is probably not the best choice for loading <em>huge</em>
+       *    terrains – fully triangulated data takes extremely much storage
+       *    space and should be avoided as long as possible (typically you will
+       *    perform the triangulation when you actually need to render it).
+       */
+      FLAGS_TERRAIN = 0x10
+   }
+
+   /**
+    * 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.
+    */
+   struct aiScene {
+      /**
+       * Any combination of the <code>aiSceneFlags</code>. By default, this
+       * value is 0, no flags are set.
+       *
+       * Most applications will want to reject all scenes with the
+       * <code>aiSceneFlags.INCOMPLETE</code> bit set.
+       */
+      uint mFlags;
+
+      /**
+       * 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 contents of the imported file.
+       */
+      aiNode* mRootNode;
+
+      /**
+       * The number of meshes in the scene.
+       */
+      uint mNumMeshes;
+
+      /**
+       * The array of meshes.
+       *
+       * Use the indices given in the <code>aiNode</code> structure to access
+       * this array. The array is <code>mNumMeshes</code> in size.
+       *
+       * If the <code>aiSceneFlags.INCOMPLETE</code> flag is not set, there
+       * will always be at least one mesh.
+       */
+      aiMesh** mMeshes;
+
+      /**
+       * The number of materials in the scene.
+       */
+      uint mNumMaterials;
+
+      /**
+       * The array of meshes.
+       *
+       * Use the indices given in the <code>aiMesh</code> structure to access
+       * this array. The array is <code>mNumMaterials</code> in size.
+       *
+       * If the <code>aiSceneFlags.INCOMPLETE</code> flag is not set, there
+       * will always be at least one material.
+       */
+      aiMaterial** mMaterials;
+
+      /**
+       * The number of animations in the scene.
+       */
+      uint mNumAnimations;
+
+      /**
+       * The array of animations.
+       *
+       * All animations imported from the given file are listed here. The array
+       * is <code>mNumAnimations</code> in size.
+      */
+      aiAnimation** mAnimations;
+
+      /**
+       * The number of textures embedded into the file.
+       */
+      uint mNumTextures;
+
+      /**
+       * The array of embedded textures.
+       *
+       * Not many file formats embed their textures into the file. An example
+       * is Quake's <code>MDL</code> format (which is also used by some
+       * GameStudio versions).
+       */
+      aiTexture** mTextures;
+
+      /**
+       * The number of light sources in the scene.
+       *
+       * Light sources are fully optional, in most cases this attribute will be
+       * 0.
+       */
+      uint mNumLights;
+
+      /**
+       * The array of light sources.
+       *
+       * All light sources imported from the given file are listed here. The
+       * array is <code>mNumLights</code> in size.
+       */
+      aiLight** mLights;
+
+      /**
+       * The number of cameras in the scene.
+       *
+       * Cameras are fully optional, in most cases this attribute
+       * will be 0.
+       */
+      uint mNumCameras;
+
+      /**
+       * The array of cameras.
+       *
+       * All cameras imported from the given file are listed here. The array is
+       * <code>mNumCameras</code> in size.
+       *
+       * The first camera in the array (if existing) is the default camera view
+       * at the scene.
+       */
+      aiCamera** mCameras;
+   }
+}

port/dAssimp/assimp/texture.d

@@ -0,0 +1,122 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Contains helper structures to handle textures in Assimp.
+ *
+ * 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.
+ */
+module assimp.texture;
+
+extern ( C ) {
+   /**
+    * Helper structure to represent a texel in a ARGB8888 format.
+    *
+    * Used by aiTexture.
+    */
+   struct aiTexel {
+   align ( 1 ):
+      ubyte b, g, r, a;
+   }
+
+   /**
+    * Helper structure to describe an embedded texture.
+    *
+    * Usually textures are contained in external files but some file formats
+    * embed them directly in the model file. There are two types of
+    * embedded textures:
+    *
+    * <em>1. Uncompressed textures</em>: The color data is given in an
+    * uncompressed format.
+    *
+    * <em>2. Compressed textures</em> stored in a file format like PNG or JPEG.
+    * 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.
+    */
+   struct aiTexture {
+      /**
+       * Width of the texture, in pixels.
+       *
+       * If <code>mHeight</code> is zero the texture is compressed in a format
+       * like JPEG. In this case, this value specifies the size of the memory
+       * area <code>pcData</code> is pointing to, in bytes.
+       */
+      uint mWidth;
+
+      /**
+       * Height of the texture, in pixels.
+       *
+       * If this value is zero, <code>pcData</code> points to an compressed
+       * texture in any format (e.g. JPEG).
+       */
+      uint mHeight;
+
+      /**
+       * A hint from the loader to make it easier for applications to determine
+       * the type of embedded compressed textures.
+       *
+       * If <code>mHeight</code> is not 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 byte will always be '\0'.
+       */
+      char achFormatHint[4];
+
+      /**
+       * Data of the texture.
+       *
+       * Points to an array of <code>mWidth * mHeight</code>
+       * <code>aiTexel</code>s. The format of the texture data is always
+       * ARGB8888 to make the implementation for user of the library as easy as
+       * possible.
+       *
+       * If <code>mHeight</code> is 0, this is a pointer to a memory buffer of
+       * size <code>mWidth</code> containing the compressed texture data.
+       */
+      aiTexel* pcData;
+   }
+}

port/dAssimp/assimp/types.d

@@ -0,0 +1,232 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Contains miscellaneous types used in Assimp's C API.
+ */
+module assimp.types;
+
+extern ( C ) {
+   /**
+    * Our own C boolean type.
+    */
+   enum aiBool : int {
+      FALSE = 0,
+      TRUE = 1
+   }
+
+   /**
+    * Type definition for log stream callback function pointers.
+    */
+   alias void function( char* message, char* user ) aiLogStreamCallback;
+
+   /**
+    * Represents a log stream. A log stream receives all log messages and
+    * streams them somewhere.
+    *
+    * See: <code>aiGetPredefinedLogStream</code>,
+    *    <code>aiAttachLogStream</code> and <code>aiDetachLogStream</code>.
+    */
+   struct aiLogStream {
+      /**
+       * Callback function to be called when a new message arrives.
+       */
+      aiLogStreamCallback callback;
+
+      /**
+       * User data to be passed to the callback.
+       */
+      char* user;
+   }
+
+   /**
+    * Maximum dimension for <code>aiString</code>s.
+    *
+    * Assimp strings are zero terminated.
+    */
+   const size_t MAXLEN = 1024;
+
+   /**
+    * Represents a string, zero byte terminated.
+    *
+    * The length of such a string is limited to <code>MAXLEN</code> characters
+    * (excluding the terminal \0).
+    *
+    * To access an aiString from D you might want to use something like the
+    * following piece of code:
+    * ---
+    * char[] importAiString( aiString* s ) {
+    *  return s.data[ 0 .. s.length ];
+    * }
+    * ---
+    */
+   struct aiString {
+      /**
+       * Length of the string (excluding the terminal \0).
+       */
+      size_t length;
+
+      /**
+       * String buffer.
+       *
+       * Size limit is <code>MAXLEN</code>.
+       */
+      char data[ MAXLEN ];
+   }
+
+   /**
+    * Standard return type for some library functions.
+    */
+   enum aiReturn : uint {
+      /**
+       * Indicates that a function was successful.
+       */
+      SUCCESS = 0x0,
+
+      /**
+       * Indicates that a function failed.
+       */
+      FAILURE = -0x1,
+
+      /**
+       * Indicates that not enough memory was available to perform the
+       * requested operation.
+       */
+      OUTOFMEMORY = -0x3
+   }
+
+   /**
+    * Seek origins (for the virtual file system API).
+    */
+   enum aiOrigin : uint {
+      /**
+       * Beginning of the file.
+       */
+      SET = 0x0,
+
+      /**
+       * Current position of the file pointer.
+       */
+      CUR = 0x1,
+
+      /**
+       * End of the file.
+       *
+       * Offsets must be negative.
+       */
+      END = 0x2
+   }
+
+   /**
+    * Enumerates predefined log streaming destinations.
+    *
+    * Logging to these streams can be enabled with a single call to
+    * <code>aiAttachPredefinedLogStream()</code>.
+    */
+   enum aiDefaultLogStream :uint {
+      /**
+       * Stream the log to a file.
+       */
+      FILE = 0x1,
+
+      /**
+       * Stream the log to standard output.
+       */
+      STDOUT = 0x2,
+
+      /**
+       * Stream the log to standard error.
+       */
+      STDERR = 0x4,
+
+      /**
+       * MSVC only: Stream the log the the debugger (this relies on
+       * <code>OutputDebugString</code> from the Win32 SDK).
+       */
+      DEBUGGER = 0x8
+   }
+
+   /**
+    * Stores the memory requirements for different components (e.g. meshes,
+    * materials, animations) of an import. All sizes are in bytes.
+    */
+   struct aiMemoryInfo {
+      /**
+       * Storage allocated for texture data.
+       */
+      uint textures;
+
+      /**
+       * Storage allocated for material data.
+       */
+      uint materials;
+
+      /**
+       * Storage allocated for mesh data.
+       */
+      uint meshes;
+
+      /**
+       * Storage allocated for node data.
+       */
+      uint nodes;
+
+      /**
+       * Storage allocated for animation data.
+       */
+      uint animations;
+
+      /**
+       * Storage allocated for camera data.
+       */
+      uint cameras;
+
+      /**
+       * Storage allocated for light data.
+       */
+      uint lights;
+
+      /**
+       * Total storage allocated for the full import.
+       */
+      uint total;
+   }
+}

port/dAssimp/assimp/versionInfo.d

@@ -0,0 +1,72 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2009, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+ * Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+ * Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Flags returned by <code>aiGetCompileFlags()</code>.
+ */
+module assimp.versionInfo;
+
+extern ( C ) {
+   /**
+    * Assimp was compiled as a shared object (Windows: DLL).
+    */
+   const uint ASSIMP_CFLAGS_SHARED = 0x1;
+
+   /**
+    * Assimp was compiled against STLport.
+    */
+   const uint ASSIMP_CFLAGS_STLPORT = 0x2;
+
+   /**
+    * Assimp was compiled as a debug build.
+    */
+   const uint ASSIMP_CFLAGS_DEBUG = 0x4;
+
+   /**
+    * Assimp was compiled with ASSIMP_BUILD_BOOST_WORKAROUND defined.
+    */
+   const uint ASSIMP_CFLAGS_NOBOOST = 0x8;
+
+   /**
+    * Assimp was compiled with ASSIMP_BUILD_SINGLETHREADED defined.
+    */
+   const uint ASSIMP_CFLAGS_SINGLETHREADED = 0x10;
+}