Apply Assimp clangformat to touched Collada files

code/Collada/ColladaExporter.h

@@ -47,29 +47,27 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_COLLADAEXPORTER_H_INC
 
 #include <assimp/ai_assert.h>
+#include <assimp/light.h>
 #include <assimp/material.h>
 #include <assimp/mesh.h>
-#include <assimp/light.h>
 #include <assimp/Exporter.hpp>
+#include <map>
 #include <sstream>
 #include <vector>
-#include <map>
 
 #include <assimp/StringUtils.h>
 
 struct aiScene;
 struct aiNode;
 
-namespace Assimp
-{
+namespace Assimp {
 
 /// Helper class to export a given scene to a Collada file. Just for my personal
 /// comfort when implementing it.
-class ColladaExporter
-{
+class ColladaExporter {
 public:
     /// Constructor for a specific scene to export
-    ColladaExporter( const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file);
+    ColladaExporter(const aiScene *pScene, IOSystem *pIOSystem, const std::string &path, const std::string &file);
 
     /// Destructor
     virtual ~ColladaExporter();
@@ -107,43 +105,49 @@ protected:
     void WriteControllerLibrary();
 
     /// Writes a skin controller of the given mesh
-    void WriteController( size_t pIndex);
+    void WriteController(size_t pIndex);
 
     /// Writes the geometry library
     void WriteGeometryLibrary();
 
     /// Writes the given mesh
-    void WriteGeometry( size_t pIndex);
+    void WriteGeometry(size_t pIndex);
 
     //enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color, FloatType_Mat4x4, FloatType_Weight };
     // customized to add animation related type
-	enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color, FloatType_Mat4x4, FloatType_Weight, FloatType_Time };
+    enum FloatDataType { FloatType_Vector,
+        FloatType_TexCoord2,
+        FloatType_TexCoord3,
+        FloatType_Color,
+        FloatType_Mat4x4,
+        FloatType_Weight,
+        FloatType_Time };
 
     /// Writes a float array of the given type
-    void WriteFloatArray( const std::string& pIdString, FloatDataType pType, const ai_real* pData, size_t pElementCount);
+    void WriteFloatArray(const std::string &pIdString, FloatDataType pType, const ai_real *pData, size_t pElementCount);
 
     /// Writes the scene library
     void WriteSceneLibrary();
 
-	// customized, Writes the animation library
-	void WriteAnimationsLibrary();
-	void WriteAnimationLibrary( size_t pIndex);
-	std::string mFoundSkeletonRootNodeID = "skeleton_root";	 	// will be replaced by found node id in the WriteNode call.
-	
+    // customized, Writes the animation library
+    void WriteAnimationsLibrary();
+    void WriteAnimationLibrary(size_t pIndex);
+    std::string mFoundSkeletonRootNodeID = "skeleton_root"; // will be replaced by found node id in the WriteNode call.
+
     /// Recursively writes the given node
-    void WriteNode( const aiScene* scene, aiNode* pNode);
+    void WriteNode(const aiScene *scene, aiNode *pNode);
 
     /// Enters a new xml element, which increases the indentation
-    void PushTag() { startstr.append( "  "); }
+    void PushTag() { startstr.append("  "); }
     /// Leaves an element, decreasing the indentation
-    void PopTag() { 
-        ai_assert( startstr.length() > 1); 
-        startstr.erase( startstr.length() - 2); 
+    void PopTag() {
+        ai_assert(startstr.length() > 1);
+        startstr.erase(startstr.length() - 2);
     }
 
     /// Creates a mesh ID for the given mesh
-    std::string GetMeshId( size_t pIndex) const {
-        return std::string( "meshId" ) + to_string(pIndex);
+    std::string GetMeshId(size_t pIndex) const {
+        return std::string("meshId") + to_string(pIndex);
     }
 
 public:
@@ -151,7 +155,7 @@ public:
     std::stringstream mOutput;
 
     /// The IOSystem for output
-    IOSystem* mIOSystem;
+    IOSystem *mIOSystem;
 
     /// Path of the directory where the scene will be exported
     const std::string mPath;
@@ -160,7 +164,7 @@ public:
     const std::string mFile;
 
     /// The scene to be written
-    const aiScene* mScene;
+    const aiScene *mScene;
     bool mSceneOwned;
 
     /// current line start string, contains the current indentation for simple stream insertion
@@ -168,55 +172,54 @@ public:
     /// current line end string for simple stream insertion
     std::string endstr;
 
-  // pair of color and texture - texture precedences color
-  struct Surface
-  {
-    bool exist;
-    aiColor4D color;
-    std::string texture;
-    size_t channel;
-    Surface() { exist = false; channel = 0; }
-  };
-
-  struct Property
-  {
-    bool exist;
-     ai_real value;
-     Property()
-         : exist(false)
-         , value(0.0)
-     {}
-  };
-
-  // summarize a material in an convenient way.
-  struct Material
-  {
-    std::string name;
-    std::string shading_model;
-    Surface ambient, diffuse, specular, emissive, reflective, transparent, normal;
-    Property shininess, transparency, index_refraction;
-
-    Material() {}
-  };
-
-  std::vector<Material> materials;
-
-  std::map<unsigned int, std::string> textures;
+    // pair of color and texture - texture precedences color
+    struct Surface {
+        bool exist;
+        aiColor4D color;
+        std::string texture;
+        size_t channel;
+        Surface() {
+            exist = false;
+            channel = 0;
+        }
+    };
+
+    struct Property {
+        bool exist;
+        ai_real value;
+        Property() :
+                exist(false),
+                value(0.0) {}
+    };
+
+    // summarize a material in an convenient way.
+    struct Material {
+        std::string name;
+        std::string shading_model;
+        Surface ambient, diffuse, specular, emissive, reflective, transparent, normal;
+        Property shininess, transparency, index_refraction;
+
+        Material() {}
+    };
+
+    std::vector<Material> materials;
+
+    std::map<unsigned int, std::string> textures;
 
 public:
-  /// Dammit C++ - y u no compile two-pass? No I have to add all methods below the struct definitions
-  /// Reads a single surface entry from the given material keys
-  void ReadMaterialSurface( Surface& poSurface, const aiMaterial* pSrcMat, aiTextureType pTexture, const char* pKey, size_t pType, size_t pIndex);
-  /// Writes an image entry for the given surface
-  void WriteImageEntry( const Surface& pSurface, const std::string& pNameAdd);
-  /// Writes the two parameters necessary for referencing a texture in an effect entry
-  void WriteTextureParamEntry( const Surface& pSurface, const std::string& pTypeName, const std::string& pMatName);
-  /// Writes a color-or-texture entry into an effect definition
-  void WriteTextureColorEntry( const Surface& pSurface, const std::string& pTypeName, const std::string& pImageName);
-  /// Writes a scalar property
-  void WriteFloatEntry( const Property& pProperty, const std::string& pTypeName);
+    /// Dammit C++ - y u no compile two-pass? No I have to add all methods below the struct definitions
+    /// Reads a single surface entry from the given material keys
+    void ReadMaterialSurface(Surface &poSurface, const aiMaterial *pSrcMat, aiTextureType pTexture, const char *pKey, size_t pType, size_t pIndex);
+    /// Writes an image entry for the given surface
+    void WriteImageEntry(const Surface &pSurface, const std::string &pNameAdd);
+    /// Writes the two parameters necessary for referencing a texture in an effect entry
+    void WriteTextureParamEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &pMatName);
+    /// Writes a color-or-texture entry into an effect definition
+    void WriteTextureColorEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &pImageName);
+    /// Writes a scalar property
+    void WriteFloatEntry(const Property &pProperty, const std::string &pTypeName);
 };
 
-}
+} // namespace Assimp
 
 #endif // !! AI_COLLADAEXPORTER_H_INC

code/Collada/ColladaHelper.cpp

@@ -43,8 +43,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "ColladaHelper.h"
 
-#include <assimp/commonMetaData.h>
 #include <assimp/ParsingUtils.h>
+#include <assimp/commonMetaData.h>
 
 namespace Assimp {
 namespace Collada {
@@ -63,42 +63,35 @@ const MetaKeyPairVector &GetColladaAssimpMetaKeys() {
 
 const MetaKeyPairVector MakeColladaAssimpMetaKeysCamelCase() {
     MetaKeyPairVector result = MakeColladaAssimpMetaKeys();
-    for (auto &val : result)
-    {
+    for (auto &val : result) {
         ToCamelCase(val.first);
     }
     return result;
 };
 
-const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase()
-{
+const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase() {
     static const MetaKeyPairVector result = MakeColladaAssimpMetaKeysCamelCase();
     return result;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Convert underscore_separated to CamelCase: "authoring_tool" becomes "AuthoringTool"
-void ToCamelCase(std::string &text)
-{
+void ToCamelCase(std::string &text) {
     if (text.empty())
         return;
     // Capitalise first character
     auto it = text.begin();
     (*it) = ToUpper(*it);
     ++it;
-    for (/*started above*/ ; it != text.end(); /*iterated below*/)
-    {
-        if ((*it) == '_')
-        {
+    for (/*started above*/; it != text.end(); /*iterated below*/) {
+        if ((*it) == '_') {
             it = text.erase(it);
             if (it != text.end())
                 (*it) = ToUpper(*it);
-        }
-        else
-        {
+        } else {
             // Make lower case
             (*it) = ToLower(*it);
-            ++it;               
+            ++it;
         }
     }
 }

code/Collada/ColladaHelper.h

@@ -45,31 +45,28 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_COLLADAHELPER_H_INC
 #define AI_COLLADAHELPER_H_INC
 
-#include <map>
-#include <vector>
-#include <set>
-#include <stdint.h>
 #include <assimp/light.h>
-#include <assimp/mesh.h>
 #include <assimp/material.h>
+#include <assimp/mesh.h>
+#include <stdint.h>
+#include <map>
+#include <set>
+#include <vector>
 
 struct aiMaterial;
 
-namespace Assimp    {
-namespace Collada       {
+namespace Assimp {
+namespace Collada {
 
 /** Collada file versions which evolved during the years ... */
-enum FormatVersion
-{
+enum FormatVersion {
     FV_1_5_n,
     FV_1_4_n,
     FV_1_3_n
 };
 
-
 /** Transformation types that can be applied to a node */
-enum TransformType
-{
+enum TransformType {
     TF_LOOKAT,
     TF_ROTATE,
     TF_TRANSLATE,
@@ -79,10 +76,9 @@ enum TransformType
 };
 
 /** Different types of input data to a vertex or face */
-enum InputType
-{
+enum InputType {
     IT_Invalid,
-    IT_Vertex,  // special type for per-index data referring to the <vertices> element carrying the per-vertex data.
+    IT_Vertex, // special type for per-index data referring to the <vertices> element carrying the per-vertex data.
     IT_Position,
     IT_Normal,
     IT_Texcoord,
@@ -92,15 +88,13 @@ enum InputType
 };
 
 /** Supported controller types */
-enum ControllerType
-{
+enum ControllerType {
     Skin,
     Morph
 };
 
 /** Supported morph methods */
-enum MorphMethod
-{
+enum MorphMethod {
     Normalized,
     Relative
 };
@@ -118,24 +112,21 @@ const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase();
 void ToCamelCase(std::string &text);
 
 /** Contains all data for one of the different transformation types */
-struct Transform
-{
-    std::string mID;  ///< SID of the transform step, by which anim channels address their target node
+struct Transform {
+    std::string mID; ///< SID of the transform step, by which anim channels address their target node
     TransformType mType;
     ai_real f[16]; ///< Interpretation of data depends on the type of the transformation
 };
 
 /** A collada camera. */
-struct Camera
-{
-    Camera()
-        :   mOrtho  (false)
-        ,   mHorFov (10e10f)
-        ,   mVerFov (10e10f)
-        ,   mAspect (10e10f)
-        ,   mZNear  (0.1f)
-        ,   mZFar   (1000.f)
-    {}
+struct Camera {
+    Camera() :
+            mOrtho(false),
+            mHorFov(10e10f),
+            mVerFov(10e10f),
+            mAspect(10e10f),
+            mZNear(0.1f),
+            mZFar(1000.f) {}
 
     // Name of camera
     std::string mName;
@@ -159,19 +150,17 @@ struct Camera
 #define ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET 1e9f
 
 /** A collada light source. */
-struct Light
-{
-    Light()
-        :   mType            (aiLightSource_UNDEFINED)
-        ,   mAttConstant     (1.f)
-        ,   mAttLinear       (0.f)
-        ,   mAttQuadratic    (0.f)
-        ,   mFalloffAngle    (180.f)
-        ,   mFalloffExponent (0.f)
-        ,   mPenumbraAngle   (ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET)
-        ,   mOuterAngle      (ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET)
-        ,   mIntensity       (1.f)
-    {}
+struct Light {
+    Light() :
+            mType(aiLightSource_UNDEFINED),
+            mAttConstant(1.f),
+            mAttLinear(0.f),
+            mAttQuadratic(0.f),
+            mFalloffAngle(180.f),
+            mFalloffExponent(0.f),
+            mPenumbraAngle(ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET),
+            mOuterAngle(ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET),
+            mIntensity(1.f) {}
 
     //! Type of the light source aiLightSourceType + ambient
     unsigned int mType;
@@ -180,7 +169,7 @@ struct Light
     aiColor3D mColor;
 
     //! Light attenuation
-    ai_real mAttConstant,mAttLinear,mAttQuadratic;
+    ai_real mAttConstant, mAttLinear, mAttQuadratic;
 
     //! Spot light falloff
     ai_real mFalloffAngle;
@@ -198,12 +187,10 @@ struct Light
 };
 
 /** Short vertex index description */
-struct InputSemanticMapEntry
-{
-    InputSemanticMapEntry()
-        :   mSet(0)
-        ,   mType(IT_Invalid)
-    {}
+struct InputSemanticMapEntry {
+    InputSemanticMapEntry() :
+            mSet(0),
+            mType(IT_Invalid) {}
 
     //! Index of set, optional
     unsigned int mSet;
@@ -213,8 +200,7 @@ struct InputSemanticMapEntry
 };
 
 /** Table to map from effect to vertex input semantics */
-struct SemanticMappingTable
-{
+struct SemanticMappingTable {
     //! Name of material
     std::string mMatName;
 
@@ -222,7 +208,7 @@ struct SemanticMappingTable
     std::map<std::string, InputSemanticMapEntry> mMap;
 
     //! For std::find
-    bool operator == (const std::string& s) const {
+    bool operator==(const std::string &s) const {
         return s == mMatName;
     }
 };
@@ -230,8 +216,7 @@ struct SemanticMappingTable
 /** A reference to a mesh inside a node, including materials assigned to the various subgroups.
  * The ID refers to either a mesh or a controller which specifies the mesh
  */
-struct MeshInstance
-{
+struct MeshInstance {
     ///< ID of the mesh or controller to be instanced
     std::string mMeshOrController;
 
@@ -240,34 +225,30 @@ struct MeshInstance
 };
 
 /** A reference to a camera inside a node*/
-struct CameraInstance
-{
-     ///< ID of the camera
+struct CameraInstance {
+    ///< ID of the camera
     std::string mCamera;
 };
 
 /** A reference to a light inside a node*/
-struct LightInstance
-{
-     ///< ID of the camera
+struct LightInstance {
+    ///< ID of the camera
     std::string mLight;
 };
 
 /** A reference to a node inside a node*/
-struct NodeInstance
-{
-     ///< ID of the node
+struct NodeInstance {
+    ///< ID of the node
     std::string mNode;
 };
 
 /** A node in a scene hierarchy */
-struct Node
-{
+struct Node {
     std::string mName;
     std::string mID;
     std::string mSID;
-    Node* mParent;
-    std::vector<Node*> mChildren;
+    Node *mParent;
+    std::vector<Node *> mChildren;
 
     /** Operations in order to calculate the resulting transformation to parent. */
     std::vector<Transform> mTransforms;
@@ -288,77 +269,78 @@ struct Node
     std::string mPrimaryCamera;
 
     //! Constructor. Begin with a zero parent
-    Node()
-    : mParent( nullptr ){
+    Node() :
+            mParent(nullptr) {
         // empty
     }
 
     //! Destructor: delete all children subsequently
     ~Node() {
-        for( std::vector<Node*>::iterator it = mChildren.begin(); it != mChildren.end(); ++it)
+        for (std::vector<Node *>::iterator it = mChildren.begin(); it != mChildren.end(); ++it)
             delete *it;
     }
 };
 
 /** Data source array: either floats or strings */
-struct Data
-{
+struct Data {
     bool mIsStringArray;
     std::vector<ai_real> mValues;
     std::vector<std::string> mStrings;
 };
 
 /** Accessor to a data array */
-struct Accessor
-{
-    size_t mCount;   // in number of objects
-    size_t mSize;    // size of an object, in elements (floats or strings, mostly 1)
-    size_t mOffset;  // in number of values
-    size_t mStride;  // Stride in number of values
+struct Accessor {
+    size_t mCount; // in number of objects
+    size_t mSize; // size of an object, in elements (floats or strings, mostly 1)
+    size_t mOffset; // in number of values
+    size_t mStride; // Stride in number of values
     std::vector<std::string> mParams; // names of the data streams in the accessors. Empty string tells to ignore.
     size_t mSubOffset[4]; // Suboffset inside the object for the common 4 elements. For a vector, that's XYZ, for a color RGBA and so on.
-                          // For example, SubOffset[0] denotes which of the values inside the object is the vector X component.
-    std::string mSource;   // URL of the source array
-    mutable const Data* mData; // Pointer to the source array, if resolved. NULL else
-
-    Accessor()
-    {
-        mCount = 0; mSize = 0; mOffset = 0; mStride = 0; mData = NULL;
+            // For example, SubOffset[0] denotes which of the values inside the object is the vector X component.
+    std::string mSource; // URL of the source array
+    mutable const Data *mData; // Pointer to the source array, if resolved. NULL else
+
+    Accessor() {
+        mCount = 0;
+        mSize = 0;
+        mOffset = 0;
+        mStride = 0;
+        mData = NULL;
         mSubOffset[0] = mSubOffset[1] = mSubOffset[2] = mSubOffset[3] = 0;
     }
 };
 
 /** A single face in a mesh */
-struct Face
-{
+struct Face {
     std::vector<size_t> mIndices;
 };
 
 /** An input channel for mesh data, referring to a single accessor */
-struct InputChannel
-{
-    InputType mType;      // Type of the data
-    size_t mIndex;        // Optional index, if multiple sets of the same data type are given
-    size_t mOffset;       // Index offset in the indices array of per-face indices. Don't ask, can't explain that any better.
+struct InputChannel {
+    InputType mType; // Type of the data
+    size_t mIndex; // Optional index, if multiple sets of the same data type are given
+    size_t mOffset; // Index offset in the indices array of per-face indices. Don't ask, can't explain that any better.
     std::string mAccessor; // ID of the accessor where to read the actual values from.
-    mutable const Accessor* mResolved; // Pointer to the accessor, if resolved. NULL else
+    mutable const Accessor *mResolved; // Pointer to the accessor, if resolved. NULL else
 
-    InputChannel() { mType = IT_Invalid; mIndex = 0; mOffset = 0; mResolved = NULL; }
+    InputChannel() {
+        mType = IT_Invalid;
+        mIndex = 0;
+        mOffset = 0;
+        mResolved = NULL;
+    }
 };
 
 /** Subset of a mesh with a certain material */
-struct SubMesh
-{
+struct SubMesh {
     std::string mMaterial; ///< subgroup identifier
     size_t mNumFaces; ///< number of faces in this submesh
 };
 
 /** Contains data for a single mesh */
-struct Mesh
-{
-    Mesh()
-    {
-        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
+struct Mesh {
+    Mesh() {
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i)
             mNumUVComponents[i] = 2;
     }
 
@@ -377,7 +359,7 @@ struct Mesh
     std::vector<aiVector3D> mTangents;
     std::vector<aiVector3D> mBitangents;
     std::vector<aiVector3D> mTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-    std::vector<aiColor4D>  mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
+    std::vector<aiColor4D> mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
 
     unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS];
 
@@ -394,8 +376,7 @@ struct Mesh
 };
 
 /** Which type of primitives the ReadPrimitives() function is going to read */
-enum PrimitiveType
-{
+enum PrimitiveType {
     Prim_Invalid,
     Prim_Lines,
     Prim_LineStrip,
@@ -407,8 +388,7 @@ enum PrimitiveType
 };
 
 /** A skeleton controller to deform a mesh with the use of joints */
-struct Controller
-{
+struct Controller {
     // controller type
     ControllerType mType;
 
@@ -436,36 +416,32 @@ struct Controller
     std::vector<size_t> mWeightCounts;
 
     // JointIndex-WeightIndex pairs for all vertices
-    std::vector< std::pair<size_t, size_t> > mWeights;
+    std::vector<std::pair<size_t, size_t>> mWeights;
 
     std::string mMorphTarget;
     std::string mMorphWeight;
 };
 
 /** A collada material. Pretty much the only member is a reference to an effect. */
-struct Material
-{
+struct Material {
     std::string mName;
     std::string mEffect;
 };
 
 /** Type of the effect param */
-enum ParamType
-{
+enum ParamType {
     Param_Sampler,
     Param_Surface
 };
 
 /** A param for an effect. Might be of several types, but they all just refer to each other, so I summarize them */
-struct EffectParam
-{
+struct EffectParam {
     ParamType mType;
     std::string mReference; // to which other thing the param is referring to.
 };
 
 /** Shading type supported by the standard effect spec of Collada */
-enum ShadeType
-{
+enum ShadeType {
     Shade_Invalid,
     Shade_Constant,
     Shade_Lambert,
@@ -474,18 +450,16 @@ enum ShadeType
 };
 
 /** Represents a texture sampler in collada */
-struct Sampler
-{
-    Sampler()
-        :   mWrapU      (true)
-        ,   mWrapV      (true)
-        ,   mMirrorU    ()
-        ,   mMirrorV    ()
-        ,   mOp         (aiTextureOp_Multiply)
-        ,   mUVId       (UINT_MAX)
-        ,   mWeighting  (1.f)
-        ,   mMixWithPrevious (1.f)
-    {}
+struct Sampler {
+    Sampler() :
+            mWrapU(true),
+            mWrapV(true),
+            mMirrorU(),
+            mMirrorV(),
+            mOp(aiTextureOp_Multiply),
+            mUVId(UINT_MAX),
+            mWeighting(1.f),
+            mMixWithPrevious(1.f) {}
 
     /** Name of image reference
      */
@@ -537,18 +511,17 @@ struct Sampler
 
 /** A collada effect. Can contain about anything according to the Collada spec,
     but we limit our version to a reasonable subset. */
-struct Effect
-{
+struct Effect {
     // Shading mode
     ShadeType mShadeType;
 
     // Colors
     aiColor4D mEmissive, mAmbient, mDiffuse, mSpecular,
-        mTransparent, mReflective;
+            mTransparent, mReflective;
 
     // Textures
     Sampler mTexEmissive, mTexAmbient, mTexDiffuse, mTexSpecular,
-        mTexTransparent, mTexBump, mTexReflective;
+            mTexTransparent, mTexBump, mTexReflective;
 
     // Scalar factory
     ai_real mShininess, mRefractIndex, mReflectivity;
@@ -566,30 +539,28 @@ struct Effect
     // Double-sided?
     bool mDoubleSided, mWireframe, mFaceted;
 
-    Effect()
-        : mShadeType    (Shade_Phong)
-        , mEmissive     ( 0, 0, 0, 1)
-        , mAmbient      ( 0.1f, 0.1f, 0.1f, 1)
-        , mDiffuse      ( 0.6f, 0.6f, 0.6f, 1)
-        , mSpecular     ( 0.4f, 0.4f, 0.4f, 1)
-        , mTransparent  ( 0, 0, 0, 1)
-        , mShininess    (10.0f)
-        , mRefractIndex (1.f)
-        , mReflectivity (0.f)
-        , mTransparency (1.f)
-        , mHasTransparency (false)
-        , mRGBTransparency(false)
-        , mInvertTransparency(false)
-        , mDoubleSided  (false)
-        , mWireframe    (false)
-        , mFaceted      (false)
-    {
+    Effect() :
+            mShadeType(Shade_Phong),
+            mEmissive(0, 0, 0, 1),
+            mAmbient(0.1f, 0.1f, 0.1f, 1),
+            mDiffuse(0.6f, 0.6f, 0.6f, 1),
+            mSpecular(0.4f, 0.4f, 0.4f, 1),
+            mTransparent(0, 0, 0, 1),
+            mShininess(10.0f),
+            mRefractIndex(1.f),
+            mReflectivity(0.f),
+            mTransparency(1.f),
+            mHasTransparency(false),
+            mRGBTransparency(false),
+            mInvertTransparency(false),
+            mDoubleSided(false),
+            mWireframe(false),
+            mFaceted(false) {
     }
 };
 
 /** An image, meaning texture */
-struct Image
-{
+struct Image {
     std::string mFileName;
 
     /** Embedded image data */
@@ -600,8 +571,7 @@ struct Image
 };
 
 /** An animation channel. */
-struct AnimationChannel
-{
+struct AnimationChannel {
     /** URL of the data to animate. Could be about anything, but we support only the
      * "NodeID/TransformID.SubElement" notation
      */
@@ -620,8 +590,7 @@ struct AnimationChannel
 };
 
 /** An animation. Container for 0-x animation channels or 0-x animations */
-struct Animation
-{
+struct Animation {
     /** Anim name */
     std::string mName;
 
@@ -629,96 +598,86 @@ struct Animation
     std::vector<AnimationChannel> mChannels;
 
     /** the sub-animations, if any */
-    std::vector<Animation*> mSubAnims;
+    std::vector<Animation *> mSubAnims;
 
     /** Destructor */
-    ~Animation()
-    {
-        for( std::vector<Animation*>::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it)
+    ~Animation() {
+        for (std::vector<Animation *>::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it)
             delete *it;
     }
 
-	/** Collect all channels in the animation hierarchy into a single channel list. */
-	void CollectChannelsRecursively(std::vector<AnimationChannel> &channels)
-	{
-		channels.insert(channels.end(), mChannels.begin(), mChannels.end());
+    /** Collect all channels in the animation hierarchy into a single channel list. */
+    void CollectChannelsRecursively(std::vector<AnimationChannel> &channels) {
+        channels.insert(channels.end(), mChannels.begin(), mChannels.end());
 
-		for (std::vector<Animation*>::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it)
-		{
-			Animation *pAnim = (*it);
+        for (std::vector<Animation *>::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it) {
+            Animation *pAnim = (*it);
 
-			pAnim->CollectChannelsRecursively(channels);
-		}
-	}
+            pAnim->CollectChannelsRecursively(channels);
+        }
+    }
 
-	/** Combine all single-channel animations' channel into the same (parent) animation channel list. */
-	void CombineSingleChannelAnimations()
-	{
-		CombineSingleChannelAnimationsRecursively(this);
-	}
+    /** Combine all single-channel animations' channel into the same (parent) animation channel list. */
+    void CombineSingleChannelAnimations() {
+        CombineSingleChannelAnimationsRecursively(this);
+    }
 
-	void CombineSingleChannelAnimationsRecursively(Animation *pParent)
-	{
-		std::set<std::string> childrenTargets;
-		bool childrenAnimationsHaveDifferentChannels = true;
+    void CombineSingleChannelAnimationsRecursively(Animation *pParent) {
+        std::set<std::string> childrenTargets;
+        bool childrenAnimationsHaveDifferentChannels = true;
 
-		for (std::vector<Animation*>::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();)
-		{
-			Animation *anim = *it;
-			CombineSingleChannelAnimationsRecursively(anim);
+        for (std::vector<Animation *>::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();) {
+            Animation *anim = *it;
+            CombineSingleChannelAnimationsRecursively(anim);
 
-			if (childrenAnimationsHaveDifferentChannels && anim->mChannels.size() == 1 &&
-				childrenTargets.find(anim->mChannels[0].mTarget) == childrenTargets.end()) {
-				childrenTargets.insert(anim->mChannels[0].mTarget);
-			} else {
-				childrenAnimationsHaveDifferentChannels = false;
-			}
+            if (childrenAnimationsHaveDifferentChannels && anim->mChannels.size() == 1 &&
+                    childrenTargets.find(anim->mChannels[0].mTarget) == childrenTargets.end()) {
+                childrenTargets.insert(anim->mChannels[0].mTarget);
+            } else {
+                childrenAnimationsHaveDifferentChannels = false;
+            }
 
-			++it;
-		}
+            ++it;
+        }
 
-		// We only want to combine animations if they have different channels
-		if (childrenAnimationsHaveDifferentChannels)
-		{
-			for (std::vector<Animation*>::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();)
-			{
-				Animation *anim = *it;
+        // We only want to combine animations if they have different channels
+        if (childrenAnimationsHaveDifferentChannels) {
+            for (std::vector<Animation *>::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();) {
+                Animation *anim = *it;
 
-				pParent->mChannels.push_back(anim->mChannels[0]);
+                pParent->mChannels.push_back(anim->mChannels[0]);
 
-				it = pParent->mSubAnims.erase(it);
+                it = pParent->mSubAnims.erase(it);
 
-				delete anim;
-				continue;
-			}
-		}
-	}
+                delete anim;
+                continue;
+            }
+        }
+    }
 };
 
 /** Description of a collada animation channel which has been determined to affect the current node */
-struct ChannelEntry
-{
-    const Collada::AnimationChannel* mChannel; ///> the source channel
+struct ChannelEntry {
+    const Collada::AnimationChannel *mChannel; ///> the source channel
     std::string mTargetId;
-    std::string mTransformId;   // the ID of the transformation step of the node which is influenced
+    std::string mTransformId; // the ID of the transformation step of the node which is influenced
     size_t mTransformIndex; // Index into the node's transform chain to apply the channel to
     size_t mSubElement; // starting index inside the transform data
 
     // resolved data references
-    const Collada::Accessor* mTimeAccessor; ///> Collada accessor to the time values
-    const Collada::Data* mTimeData; ///> Source data array for the time values
-    const Collada::Accessor* mValueAccessor; ///> Collada accessor to the key value values
-    const Collada::Data* mValueData; ///> Source datat array for the key value values
-
-    ChannelEntry()
-      : mChannel()
-      , mTransformIndex()
-      , mSubElement()
-      , mTimeAccessor()
-      , mTimeData()
-      , mValueAccessor()
-      , mValueData()
-   {}
+    const Collada::Accessor *mTimeAccessor; ///> Collada accessor to the time values
+    const Collada::Data *mTimeData; ///> Source data array for the time values
+    const Collada::Accessor *mValueAccessor; ///> Collada accessor to the key value values
+    const Collada::Data *mValueData; ///> Source datat array for the key value values
+
+    ChannelEntry() :
+            mChannel(),
+            mTransformIndex(),
+            mSubElement(),
+            mTimeAccessor(),
+            mTimeData(),
+            mValueAccessor(),
+            mValueData() {}
 };
 
 } // end of namespace Collada

code/Collada/ColladaParser.h

@@ -47,346 +47,345 @@
 #ifndef AI_COLLADAPARSER_H_INC
 #define AI_COLLADAPARSER_H_INC
 
-#include <assimp/irrXMLWrapper.h>
 #include "ColladaHelper.h"
-#include <assimp/ai_assert.h>
 #include <assimp/TinyFormatter.h>
+#include <assimp/ai_assert.h>
+#include <assimp/irrXMLWrapper.h>
 
-namespace Assimp
-{
-    class ZipArchiveIOSystem;
+namespace Assimp {
+class ZipArchiveIOSystem;
 
-    // ------------------------------------------------------------------------------------------
-    /** Parser helper class for the Collada loader.
+// ------------------------------------------------------------------------------------------
+/** Parser helper class for the Collada loader.
      *
      *  Does all the XML reading and builds internal data structures from it,
      *  but leaves the resolving of all the references to the loader.
      */
-    class ColladaParser
-    {
-        friend class ColladaLoader;
+class ColladaParser {
+    friend class ColladaLoader;
 
-        /** Converts a path read from a collada file to the usual representation */
-        static void UriDecodePath(aiString& ss);
+    /** Converts a path read from a collada file to the usual representation */
+    static void UriDecodePath(aiString &ss);
 
-    protected:
-        /** Map for generic metadata as aiString */
-        typedef std::map<std::string, aiString> StringMetaData;
+protected:
+    /** Map for generic metadata as aiString */
+    typedef std::map<std::string, aiString> StringMetaData;
 
-        /** Constructor from XML file */
-        ColladaParser(IOSystem* pIOHandler, const std::string& pFile);
+    /** Constructor from XML file */
+    ColladaParser(IOSystem *pIOHandler, const std::string &pFile);
 
-        /** Destructor */
-        ~ColladaParser();
+    /** Destructor */
+    ~ColladaParser();
 
-        /** Attempts to read the ZAE manifest and returns the DAE to open */
-        static std::string ReadZaeManifest(ZipArchiveIOSystem &zip_archive);
+    /** Attempts to read the ZAE manifest and returns the DAE to open */
+    static std::string ReadZaeManifest(ZipArchiveIOSystem &zip_archive);
 
-        /** Reads the contents of the file */
-        void ReadContents();
+    /** Reads the contents of the file */
+    void ReadContents();
 
-        /** Reads the structure of the file */
-        void ReadStructure();
+    /** Reads the structure of the file */
+    void ReadStructure();
 
-        /** Reads asset information such as coordinate system information and legal blah */
-        void ReadAssetInfo();
+    /** Reads asset information such as coordinate system information and legal blah */
+    void ReadAssetInfo();
 
-        /** Reads contributor information such as author and legal blah */
-        void ReadContributorInfo();
+    /** Reads contributor information such as author and legal blah */
+    void ReadContributorInfo();
 
-        /** Reads generic metadata into provided map and renames keys for Assimp */
-        void ReadMetaDataItem(StringMetaData &metadata);
+    /** Reads generic metadata into provided map and renames keys for Assimp */
+    void ReadMetaDataItem(StringMetaData &metadata);
 
-        /** Reads the animation library */
-        void ReadAnimationLibrary();
+    /** Reads the animation library */
+    void ReadAnimationLibrary();
 
-		/** Reads the animation clip library */
-		void ReadAnimationClipLibrary();
+    /** Reads the animation clip library */
+    void ReadAnimationClipLibrary();
 
-        /** Unwrap controllers dependency hierarchy */
-        void PostProcessControllers();
-    
-		/** Re-build animations from animation clip library, if present, otherwise combine single-channel animations */
-		void PostProcessRootAnimations();
+    /** Unwrap controllers dependency hierarchy */
+    void PostProcessControllers();
 
-        /** Reads an animation into the given parent structure */
-        void ReadAnimation( Collada::Animation* pParent);
+    /** Re-build animations from animation clip library, if present, otherwise combine single-channel animations */
+    void PostProcessRootAnimations();
 
-        /** Reads an animation sampler into the given anim channel */
-        void ReadAnimationSampler( Collada::AnimationChannel& pChannel);
+    /** Reads an animation into the given parent structure */
+    void ReadAnimation(Collada::Animation *pParent);
 
-        /** Reads the skeleton controller library */
-        void ReadControllerLibrary();
+    /** Reads an animation sampler into the given anim channel */
+    void ReadAnimationSampler(Collada::AnimationChannel &pChannel);
 
-        /** Reads a controller into the given mesh structure */
-        void ReadController( Collada::Controller& pController);
+    /** Reads the skeleton controller library */
+    void ReadControllerLibrary();
 
-        /** Reads the joint definitions for the given controller */
-        void ReadControllerJoints( Collada::Controller& pController);
+    /** Reads a controller into the given mesh structure */
+    void ReadController(Collada::Controller &pController);
 
-        /** Reads the joint weights for the given controller */
-        void ReadControllerWeights( Collada::Controller& pController);
+    /** Reads the joint definitions for the given controller */
+    void ReadControllerJoints(Collada::Controller &pController);
 
-        /** Reads the image library contents */
-        void ReadImageLibrary();
+    /** Reads the joint weights for the given controller */
+    void ReadControllerWeights(Collada::Controller &pController);
 
-        /** Reads an image entry into the given image */
-        void ReadImage( Collada::Image& pImage);
+    /** Reads the image library contents */
+    void ReadImageLibrary();
 
-        /** Reads the material library */
-        void ReadMaterialLibrary();
+    /** Reads an image entry into the given image */
+    void ReadImage(Collada::Image &pImage);
 
-        /** Reads a material entry into the given material */
-        void ReadMaterial( Collada::Material& pMaterial);
+    /** Reads the material library */
+    void ReadMaterialLibrary();
 
-        /** Reads the camera library */
-        void ReadCameraLibrary();
+    /** Reads a material entry into the given material */
+    void ReadMaterial(Collada::Material &pMaterial);
 
-        /** Reads a camera entry into the given camera */
-        void ReadCamera( Collada::Camera& pCamera);
+    /** Reads the camera library */
+    void ReadCameraLibrary();
 
-        /** Reads the light library */
-        void ReadLightLibrary();
+    /** Reads a camera entry into the given camera */
+    void ReadCamera(Collada::Camera &pCamera);
 
-        /** Reads a light entry into the given light */
-        void ReadLight( Collada::Light& pLight);
+    /** Reads the light library */
+    void ReadLightLibrary();
 
-        /** Reads the effect library */
-        void ReadEffectLibrary();
+    /** Reads a light entry into the given light */
+    void ReadLight(Collada::Light &pLight);
 
-        /** Reads an effect entry into the given effect*/
-        void ReadEffect( Collada::Effect& pEffect);
+    /** Reads the effect library */
+    void ReadEffectLibrary();
 
-        /** Reads an COMMON effect profile */
-        void ReadEffectProfileCommon( Collada::Effect& pEffect);
+    /** Reads an effect entry into the given effect*/
+    void ReadEffect(Collada::Effect &pEffect);
 
-        /** Read sampler properties */
-        void ReadSamplerProperties( Collada::Sampler& pSampler);
+    /** Reads an COMMON effect profile */
+    void ReadEffectProfileCommon(Collada::Effect &pEffect);
 
-        /** Reads an effect entry containing a color or a texture defining that color */
-        void ReadEffectColor( aiColor4D& pColor, Collada::Sampler& pSampler);
+    /** Read sampler properties */
+    void ReadSamplerProperties(Collada::Sampler &pSampler);
 
-        /** Reads an effect entry containing a float */
-        void ReadEffectFloat( ai_real& pFloat);
+    /** Reads an effect entry containing a color or a texture defining that color */
+    void ReadEffectColor(aiColor4D &pColor, Collada::Sampler &pSampler);
 
-        /** Reads an effect parameter specification of any kind */
-        void ReadEffectParam( Collada::EffectParam& pParam);
+    /** Reads an effect entry containing a float */
+    void ReadEffectFloat(ai_real &pFloat);
 
-        /** Reads the geometry library contents */
-        void ReadGeometryLibrary();
+    /** Reads an effect parameter specification of any kind */
+    void ReadEffectParam(Collada::EffectParam &pParam);
 
-        /** Reads a geometry from the geometry library. */
-        void ReadGeometry( Collada::Mesh* pMesh);
+    /** Reads the geometry library contents */
+    void ReadGeometryLibrary();
 
-        /** Reads a mesh from the geometry library */
-        void ReadMesh( Collada::Mesh* pMesh);
+    /** Reads a geometry from the geometry library. */
+    void ReadGeometry(Collada::Mesh *pMesh);
 
-        /** Reads a source element - a combination of raw data and an accessor defining
+    /** Reads a mesh from the geometry library */
+    void ReadMesh(Collada::Mesh *pMesh);
+
+    /** Reads a source element - a combination of raw data and an accessor defining
          * things that should not be redefinable. Yes, that's another rant.
          */
-        void ReadSource();
+    void ReadSource();
 
-        /** Reads a data array holding a number of elements, and stores it in the global library.
+    /** Reads a data array holding a number of elements, and stores it in the global library.
          * Currently supported are array of floats and arrays of strings.
          */
-        void ReadDataArray();
+    void ReadDataArray();
 
-        /** Reads an accessor and stores it in the global library under the given ID -
+    /** Reads an accessor and stores it in the global library under the given ID -
          * accessors use the ID of the parent <source> element
          */
-        void ReadAccessor( const std::string& pID);
+    void ReadAccessor(const std::string &pID);
 
-        /** Reads input declarations of per-vertex mesh data into the given mesh */
-        void ReadVertexData( Collada::Mesh* pMesh);
+    /** Reads input declarations of per-vertex mesh data into the given mesh */
+    void ReadVertexData(Collada::Mesh *pMesh);
 
-        /** Reads input declarations of per-index mesh data into the given mesh */
-        void ReadIndexData( Collada::Mesh* pMesh);
+    /** Reads input declarations of per-index mesh data into the given mesh */
+    void ReadIndexData(Collada::Mesh *pMesh);
 
-        /** Reads a single input channel element and stores it in the given array, if valid */
-        void ReadInputChannel( std::vector<Collada::InputChannel>& poChannels);
+    /** Reads a single input channel element and stores it in the given array, if valid */
+    void ReadInputChannel(std::vector<Collada::InputChannel> &poChannels);
 
-        /** Reads a <p> primitive index list and assembles the mesh data into the given mesh */
-        size_t ReadPrimitives( Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
-                              size_t pNumPrimitives, const std::vector<size_t>& pVCount, Collada::PrimitiveType pPrimType);
+    /** Reads a <p> primitive index list and assembles the mesh data into the given mesh */
+    size_t ReadPrimitives(Collada::Mesh *pMesh, std::vector<Collada::InputChannel> &pPerIndexChannels,
+            size_t pNumPrimitives, const std::vector<size_t> &pVCount, Collada::PrimitiveType pPrimType);
 
-        /** Copies the data for a single primitive into the mesh, based on the InputChannels */
-        void CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset,
-                        Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
-                        size_t currentPrimitive, const std::vector<size_t>& indices);
+    /** Copies the data for a single primitive into the mesh, based on the InputChannels */
+    void CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset,
+            Collada::Mesh *pMesh, std::vector<Collada::InputChannel> &pPerIndexChannels,
+            size_t currentPrimitive, const std::vector<size_t> &indices);
 
-        /** Reads one triangle of a tristrip into the mesh */
-        void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh* pMesh,
-                               std::vector<Collada::InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices);
+    /** Reads one triangle of a tristrip into the mesh */
+    void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh *pMesh,
+            std::vector<Collada::InputChannel> &pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t> &indices);
 
-        /** Extracts a single object from an input channel and stores it in the appropriate mesh data array */
-        void ExtractDataObjectFromChannel( const Collada::InputChannel& pInput, size_t pLocalIndex, Collada::Mesh* pMesh);
+    /** Extracts a single object from an input channel and stores it in the appropriate mesh data array */
+    void ExtractDataObjectFromChannel(const Collada::InputChannel &pInput, size_t pLocalIndex, Collada::Mesh *pMesh);
 
-        /** Reads the library of node hierarchies and scene parts */
-        void ReadSceneLibrary();
+    /** Reads the library of node hierarchies and scene parts */
+    void ReadSceneLibrary();
 
-        /** Reads a scene node's contents including children and stores it in the given node */
-        void ReadSceneNode( Collada::Node* pNode);
+    /** Reads a scene node's contents including children and stores it in the given node */
+    void ReadSceneNode(Collada::Node *pNode);
 
-        /** Reads a node transformation entry of the given type and adds it to the given node's transformation list. */
-        void ReadNodeTransformation( Collada::Node* pNode, Collada::TransformType pType);
+    /** Reads a node transformation entry of the given type and adds it to the given node's transformation list. */
+    void ReadNodeTransformation(Collada::Node *pNode, Collada::TransformType pType);
 
-        /** Reads a mesh reference in a node and adds it to the node's mesh list */
-        void ReadNodeGeometry( Collada::Node* pNode);
+    /** Reads a mesh reference in a node and adds it to the node's mesh list */
+    void ReadNodeGeometry(Collada::Node *pNode);
 
-        /** Reads the collada scene */
-        void ReadScene();
+    /** Reads the collada scene */
+    void ReadScene();
 
-        // Processes bind_vertex_input and bind elements
-        void ReadMaterialVertexInputBinding( Collada::SemanticMappingTable& tbl);
+    // Processes bind_vertex_input and bind elements
+    void ReadMaterialVertexInputBinding(Collada::SemanticMappingTable &tbl);
 
-        /** Reads embedded textures from a ZAE archive*/
-        void ReadEmbeddedTextures(ZipArchiveIOSystem &zip_archive);
+    /** Reads embedded textures from a ZAE archive*/
+    void ReadEmbeddedTextures(ZipArchiveIOSystem &zip_archive);
 
-    protected:
-        /** Aborts the file reading with an exception */
-        AI_WONT_RETURN void ThrowException( const std::string& pError) const AI_WONT_RETURN_SUFFIX;
-        void ReportWarning(const char* msg,...);
+protected:
+    /** Aborts the file reading with an exception */
+    AI_WONT_RETURN void ThrowException(const std::string &pError) const AI_WONT_RETURN_SUFFIX;
+    void ReportWarning(const char *msg, ...);
 
-        /** Skips all data until the end node of the current element */
-        void SkipElement();
+    /** Skips all data until the end node of the current element */
+    void SkipElement();
 
-        /** Skips all data until the end node of the given element */
-        void SkipElement( const char* pElement);
+    /** Skips all data until the end node of the given element */
+    void SkipElement(const char *pElement);
 
-        /** Compares the current xml element name to the given string and returns true if equal */
-        bool IsElement( const char* pName) const;
+    /** Compares the current xml element name to the given string and returns true if equal */
+    bool IsElement(const char *pName) const;
 
-        /** Tests for the opening tag of the given element, throws an exception if not found */
-        void TestOpening( const char* pName);
+    /** Tests for the opening tag of the given element, throws an exception if not found */
+    void TestOpening(const char *pName);
 
-        /** Tests for the closing tag of the given element, throws an exception if not found */
-        void TestClosing( const char* pName);
+    /** Tests for the closing tag of the given element, throws an exception if not found */
+    void TestClosing(const char *pName);
 
-        /** Checks the present element for the presence of the attribute, returns its index
+    /** Checks the present element for the presence of the attribute, returns its index
          or throws an exception if not found */
-        int GetAttribute( const char* pAttr) const;
+    int GetAttribute(const char *pAttr) const;
 
-        /** Returns the index of the named attribute or -1 if not found. Does not throw,
+    /** Returns the index of the named attribute or -1 if not found. Does not throw,
          therefore useful for optional attributes */
-        int TestAttribute( const char* pAttr) const;
+    int TestAttribute(const char *pAttr) const;
 
-        /** Reads the text contents of an element, throws an exception if not given.
+    /** Reads the text contents of an element, throws an exception if not given.
          Skips leading whitespace. */
-        const char* GetTextContent();
+    const char *GetTextContent();
 
-        /** Reads the text contents of an element, returns NULL if not given.
+    /** Reads the text contents of an element, returns NULL if not given.
          Skips leading whitespace. */
-        const char* TestTextContent();
+    const char *TestTextContent();
 
-        /** Reads a single bool from current text content */
-        bool ReadBoolFromTextContent();
+    /** Reads a single bool from current text content */
+    bool ReadBoolFromTextContent();
 
-        /** Reads a single float from current text content */
-        ai_real ReadFloatFromTextContent();
+    /** Reads a single float from current text content */
+    ai_real ReadFloatFromTextContent();
 
-        /** Calculates the resulting transformation from all the given transform steps */
-        aiMatrix4x4 CalculateResultTransform( const std::vector<Collada::Transform>& pTransforms) const;
+    /** Calculates the resulting transformation from all the given transform steps */
+    aiMatrix4x4 CalculateResultTransform(const std::vector<Collada::Transform> &pTransforms) const;
 
-        /** Determines the input data type for the given semantic string */
-        Collada::InputType GetTypeForSemantic( const std::string& pSemantic);
+    /** Determines the input data type for the given semantic string */
+    Collada::InputType GetTypeForSemantic(const std::string &pSemantic);
 
-        /** Finds the item in the given library by its reference, throws if not found */
-        template <typename Type> const Type& ResolveLibraryReference( const std::map<std::string, Type>& pLibrary, const std::string& pURL) const;
+    /** Finds the item in the given library by its reference, throws if not found */
+    template <typename Type>
+    const Type &ResolveLibraryReference(const std::map<std::string, Type> &pLibrary, const std::string &pURL) const;
 
-    protected:
-        /** Filename, for a verbose error message */
-        std::string mFileName;
+protected:
+    /** Filename, for a verbose error message */
+    std::string mFileName;
 
-        /** XML reader, member for everyday use */
-        irr::io::IrrXMLReader* mReader;
+    /** XML reader, member for everyday use */
+    irr::io::IrrXMLReader *mReader;
 
-        /** All data arrays found in the file by ID. Might be referred to by actually
+    /** All data arrays found in the file by ID. Might be referred to by actually
          everyone. Collada, you are a steaming pile of indirection. */
-        typedef std::map<std::string, Collada::Data> DataLibrary;
-        DataLibrary mDataLibrary;
+    typedef std::map<std::string, Collada::Data> DataLibrary;
+    DataLibrary mDataLibrary;
 
-        /** Same for accessors which define how the data in a data array is accessed. */
-        typedef std::map<std::string, Collada::Accessor> AccessorLibrary;
-        AccessorLibrary mAccessorLibrary;
+    /** Same for accessors which define how the data in a data array is accessed. */
+    typedef std::map<std::string, Collada::Accessor> AccessorLibrary;
+    AccessorLibrary mAccessorLibrary;
 
-        /** Mesh library: mesh by ID */
-        typedef std::map<std::string, Collada::Mesh*> MeshLibrary;
-        MeshLibrary mMeshLibrary;
+    /** Mesh library: mesh by ID */
+    typedef std::map<std::string, Collada::Mesh *> MeshLibrary;
+    MeshLibrary mMeshLibrary;
 
-        /** node library: root node of the hierarchy part by ID */
-        typedef std::map<std::string, Collada::Node*> NodeLibrary;
-        NodeLibrary mNodeLibrary;
+    /** node library: root node of the hierarchy part by ID */
+    typedef std::map<std::string, Collada::Node *> NodeLibrary;
+    NodeLibrary mNodeLibrary;
 
-        /** Image library: stores texture properties by ID */
-        typedef std::map<std::string, Collada::Image> ImageLibrary;
-        ImageLibrary mImageLibrary;
+    /** Image library: stores texture properties by ID */
+    typedef std::map<std::string, Collada::Image> ImageLibrary;
+    ImageLibrary mImageLibrary;
 
-        /** Effect library: surface attributes by ID */
-        typedef std::map<std::string, Collada::Effect> EffectLibrary;
-        EffectLibrary mEffectLibrary;
+    /** Effect library: surface attributes by ID */
+    typedef std::map<std::string, Collada::Effect> EffectLibrary;
+    EffectLibrary mEffectLibrary;
 
-        /** Material library: surface material by ID */
-        typedef std::map<std::string, Collada::Material> MaterialLibrary;
-        MaterialLibrary mMaterialLibrary;
+    /** Material library: surface material by ID */
+    typedef std::map<std::string, Collada::Material> MaterialLibrary;
+    MaterialLibrary mMaterialLibrary;
 
-        /** Light library: surface light by ID */
-        typedef std::map<std::string, Collada::Light> LightLibrary;
-        LightLibrary mLightLibrary;
+    /** Light library: surface light by ID */
+    typedef std::map<std::string, Collada::Light> LightLibrary;
+    LightLibrary mLightLibrary;
 
-        /** Camera library: surface material by ID */
-        typedef std::map<std::string, Collada::Camera> CameraLibrary;
-        CameraLibrary mCameraLibrary;
+    /** Camera library: surface material by ID */
+    typedef std::map<std::string, Collada::Camera> CameraLibrary;
+    CameraLibrary mCameraLibrary;
 
-        /** Controller library: joint controllers by ID */
-        typedef std::map<std::string, Collada::Controller> ControllerLibrary;
-        ControllerLibrary mControllerLibrary;
+    /** Controller library: joint controllers by ID */
+    typedef std::map<std::string, Collada::Controller> ControllerLibrary;
+    ControllerLibrary mControllerLibrary;
 
-		/** Animation library: animation references by ID */
-		typedef std::map<std::string, Collada::Animation*> AnimationLibrary;
-		AnimationLibrary mAnimationLibrary;
+    /** Animation library: animation references by ID */
+    typedef std::map<std::string, Collada::Animation *> AnimationLibrary;
+    AnimationLibrary mAnimationLibrary;
 
-		/** Animation clip library: clip animation references by ID */
-		typedef std::vector<std::pair<std::string, std::vector<std::string> > > AnimationClipLibrary;
-		AnimationClipLibrary mAnimationClipLibrary;
+    /** Animation clip library: clip animation references by ID */
+    typedef std::vector<std::pair<std::string, std::vector<std::string>>> AnimationClipLibrary;
+    AnimationClipLibrary mAnimationClipLibrary;
 
-        /** Pointer to the root node. Don't delete, it just points to one of
+    /** Pointer to the root node. Don't delete, it just points to one of
          the nodes in the node library. */
-        Collada::Node* mRootNode;
-
-        /** Root animation container */
-        Collada::Animation mAnims;
-
-        /** Size unit: how large compared to a meter */
-        ai_real mUnitSize;
-
-        /** Which is the up vector */
-        enum { UP_X, UP_Y, UP_Z } mUpDirection;
-
-        /** Asset metadata (global for scene) */
-        StringMetaData mAssetMetaData;
-
-        /** Collada file format version */
-        Collada::FormatVersion mFormat;
-    };
-
-    // ------------------------------------------------------------------------------------------------
-    // Check for element match
-    inline bool ColladaParser::IsElement( const char* pName) const
-    {
-        ai_assert( mReader->getNodeType() == irr::io::EXN_ELEMENT);
-        return ::strcmp( mReader->getNodeName(), pName) == 0;
-    }
-
-    // ------------------------------------------------------------------------------------------------
-    // Finds the item in the given library by its reference, throws if not found
-    template <typename Type>
-    const Type& ColladaParser::ResolveLibraryReference( const std::map<std::string, Type>& pLibrary, const std::string& pURL) const
-    {
-        typename std::map<std::string, Type>::const_iterator it = pLibrary.find( pURL);
-        if( it == pLibrary.end())
-            ThrowException( Formatter::format() << "Unable to resolve library reference \"" << pURL << "\"." );
-        return it->second;
-    }
+    Collada::Node *mRootNode;
+
+    /** Root animation container */
+    Collada::Animation mAnims;
+
+    /** Size unit: how large compared to a meter */
+    ai_real mUnitSize;
+
+    /** Which is the up vector */
+    enum { UP_X,
+        UP_Y,
+        UP_Z } mUpDirection;
+
+    /** Asset metadata (global for scene) */
+    StringMetaData mAssetMetaData;
+
+    /** Collada file format version */
+    Collada::FormatVersion mFormat;
+};
+
+// ------------------------------------------------------------------------------------------------
+// Check for element match
+inline bool ColladaParser::IsElement(const char *pName) const {
+    ai_assert(mReader->getNodeType() == irr::io::EXN_ELEMENT);
+    return ::strcmp(mReader->getNodeName(), pName) == 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Finds the item in the given library by its reference, throws if not found
+template <typename Type>
+const Type &ColladaParser::ResolveLibraryReference(const std::map<std::string, Type> &pLibrary, const std::string &pURL) const {
+    typename std::map<std::string, Type>::const_iterator it = pLibrary.find(pURL);
+    if (it == pLibrary.end())
+        ThrowException(Formatter::format() << "Unable to resolve library reference \"" << pURL << "\".");
+    return it->second;
+}
 
 } // end of namespace Assimp