next warnings.

code/3DS/3DSHelper.h

@@ -45,18 +45,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_3DSFILEHELPER_H_INC
 #define AI_3DSFILEHELPER_H_INC
 
-#include <assimp/SpatialSort.h>
 #include <assimp/SmoothingGroups.h>
+#include <assimp/SpatialSort.h>
 #include <assimp/StringUtils.h>
-#include <assimp/qnan.h>
-#include <assimp/material.h>
+#include <assimp/anim.h>
 #include <assimp/camera.h>
 #include <assimp/light.h>
-#include <assimp/anim.h>
+#include <assimp/material.h>
+#include <assimp/qnan.h>
 #include <stdio.h> //sprintf
 
-namespace Assimp    {
-namespace D3DS  {
+namespace Assimp {
+namespace D3DS {
 
 #include <assimp/Compiler/pushpack1.h>
 
@@ -77,15 +77,13 @@ private:
 public:
     //! data structure for a single chunk in a .3ds file
     struct Chunk {
-        uint16_t    Flag;
-        uint32_t    Size;
+        uint16_t Flag;
+        uint32_t Size;
     } PACK_STRUCT;
 
-
     //! Used for shading field in material3ds structure
     //! From AutoDesk 3ds SDK
-    typedef enum
-    {
+    typedef enum {
         // translated to gouraud shading with wireframe active
         Wire = 0x0,
 
@@ -109,59 +107,57 @@ public:
     } shadetype3ds;
 
     // Flags for animated keys
-    enum
-    {
-        KEY_USE_TENS         = 0x1,
-        KEY_USE_CONT         = 0x2,
-        KEY_USE_BIAS         = 0x4,
-        KEY_USE_EASE_TO      = 0x8,
-        KEY_USE_EASE_FROM    = 0x10
-    } ;
-
-    enum
-    {
+    enum {
+        KEY_USE_TENS = 0x1,
+        KEY_USE_CONT = 0x2,
+        KEY_USE_BIAS = 0x4,
+        KEY_USE_EASE_TO = 0x8,
+        KEY_USE_EASE_FROM = 0x10
+    };
+
+    enum {
 
         // ********************************************************************
         // Basic chunks which can be found everywhere in the file
-        CHUNK_VERSION   = 0x0002,
-        CHUNK_RGBF      = 0x0010,       // float4 R; float4 G; float4 B
-        CHUNK_RGBB      = 0x0011,       // int1 R; int1 G; int B
+        CHUNK_VERSION = 0x0002,
+        CHUNK_RGBF = 0x0010, // float4 R; float4 G; float4 B
+        CHUNK_RGBB = 0x0011, // int1 R; int1 G; int B
 
         // Linear color values (gamma = 2.2?)
-        CHUNK_LINRGBF      = 0x0013,    // float4 R; float4 G; float4 B
-        CHUNK_LINRGBB      = 0x0012,    // int1 R; int1 G; int B
+        CHUNK_LINRGBF = 0x0013, // float4 R; float4 G; float4 B
+        CHUNK_LINRGBB = 0x0012, // int1 R; int1 G; int B
 
-        CHUNK_PERCENTW  = 0x0030,       // int2   percentage
-        CHUNK_PERCENTF  = 0x0031,       // float4  percentage
-        CHUNK_PERCENTD  = 0x0032,       // float8  percentage
+        CHUNK_PERCENTW = 0x0030, // int2   percentage
+        CHUNK_PERCENTF = 0x0031, // float4  percentage
+        CHUNK_PERCENTD = 0x0032, // float8  percentage
         // ********************************************************************
 
         // Prj master chunk
-        CHUNK_PRJ       = 0xC23D,
+        CHUNK_PRJ = 0xC23D,
 
         // MDLI master chunk
-        CHUNK_MLI       = 0x3DAA,
+        CHUNK_MLI = 0x3DAA,
 
         // Primary main chunk of the .3ds file
-        CHUNK_MAIN      = 0x4D4D,
+        CHUNK_MAIN = 0x4D4D,
 
         // Mesh main chunk
-        CHUNK_OBJMESH   = 0x3D3D,
+        CHUNK_OBJMESH = 0x3D3D,
 
         // Specifies the background color of the .3ds file
         // This is passed through the material system for
         // viewing purposes.
-        CHUNK_BKGCOLOR  = 0x1200,
+        CHUNK_BKGCOLOR = 0x1200,
 
         // Specifies the ambient base color of the scene.
         // This is added to all materials in the file
-        CHUNK_AMBCOLOR  = 0x2100,
+        CHUNK_AMBCOLOR = 0x2100,
 
         // Specifies the background image for the whole scene
         // This value is passed through the material system
         // to the viewer
-        CHUNK_BIT_MAP   = 0x1100,
-        CHUNK_BIT_MAP_EXISTS  = 0x1101,
+        CHUNK_BIT_MAP = 0x1100,
+        CHUNK_BIT_MAP_EXISTS = 0x1101,
 
         // ********************************************************************
         // Viewport related stuff. Ignored
@@ -177,183 +173,204 @@ public:
         // ********************************************************************
 
         // Mesh chunks
-        CHUNK_OBJBLOCK  = 0x4000,
-        CHUNK_TRIMESH   = 0x4100,
-        CHUNK_VERTLIST  = 0x4110,
+        CHUNK_OBJBLOCK = 0x4000,
+        CHUNK_TRIMESH = 0x4100,
+        CHUNK_VERTLIST = 0x4110,
         CHUNK_VERTFLAGS = 0x4111,
-        CHUNK_FACELIST  = 0x4120,
-        CHUNK_FACEMAT   = 0x4130,
-        CHUNK_MAPLIST   = 0x4140,
-        CHUNK_SMOOLIST  = 0x4150,
-        CHUNK_TRMATRIX  = 0x4160,
+        CHUNK_FACELIST = 0x4120,
+        CHUNK_FACEMAT = 0x4130,
+        CHUNK_MAPLIST = 0x4140,
+        CHUNK_SMOOLIST = 0x4150,
+        CHUNK_TRMATRIX = 0x4160,
         CHUNK_MESHCOLOR = 0x4165,
-        CHUNK_TXTINFO   = 0x4170,
-        CHUNK_LIGHT     = 0x4600,
-        CHUNK_CAMERA    = 0x4700,
+        CHUNK_TXTINFO = 0x4170,
+        CHUNK_LIGHT = 0x4600,
+        CHUNK_CAMERA = 0x4700,
         CHUNK_HIERARCHY = 0x4F00,
 
         // Specifies the global scaling factor. This is applied
         // to the root node's transformation matrix
-        CHUNK_MASTER_SCALE    = 0x0100,
+        CHUNK_MASTER_SCALE = 0x0100,
 
         // ********************************************************************
         // Material chunks
-        CHUNK_MAT_MATERIAL  = 0xAFFF,
+        CHUNK_MAT_MATERIAL = 0xAFFF,
 
-            // asciiz containing the name of the material
-            CHUNK_MAT_MATNAME   = 0xA000,
-            CHUNK_MAT_AMBIENT   = 0xA010, // followed by color chunk
-            CHUNK_MAT_DIFFUSE   = 0xA020, // followed by color chunk
-            CHUNK_MAT_SPECULAR  = 0xA030, // followed by color chunk
+        // asciiz containing the name of the material
+        CHUNK_MAT_MATNAME = 0xA000,
+        CHUNK_MAT_AMBIENT = 0xA010, // followed by color chunk
+        CHUNK_MAT_DIFFUSE = 0xA020, // followed by color chunk
+        CHUNK_MAT_SPECULAR = 0xA030, // followed by color chunk
 
-            // Specifies the shininess of the material
-            // followed by percentage chunk
-            CHUNK_MAT_SHININESS  = 0xA040,
-            CHUNK_MAT_SHININESS_PERCENT  = 0xA041 ,
+        // Specifies the shininess of the material
+        // followed by percentage chunk
+        CHUNK_MAT_SHININESS = 0xA040,
+        CHUNK_MAT_SHININESS_PERCENT = 0xA041,
 
-            // Specifies the shading mode to be used
-            // followed by a short
-            CHUNK_MAT_SHADING  = 0xA100,
+        // Specifies the shading mode to be used
+        // followed by a short
+        CHUNK_MAT_SHADING = 0xA100,
 
-            // NOTE: Emissive color (self illumination) seems not
-            // to be a color but a single value, type is unknown.
-            // Make the parser accept both of them.
-            // followed by percentage chunk (?)
-            CHUNK_MAT_SELF_ILLUM = 0xA080,
+        // NOTE: Emissive color (self illumination) seems not
+        // to be a color but a single value, type is unknown.
+        // Make the parser accept both of them.
+        // followed by percentage chunk (?)
+        CHUNK_MAT_SELF_ILLUM = 0xA080,
 
-            // Always followed by percentage chunk  (?)
-            CHUNK_MAT_SELF_ILPCT = 0xA084,
+        // Always followed by percentage chunk  (?)
+        CHUNK_MAT_SELF_ILPCT = 0xA084,
 
-            // Always followed by percentage chunk
-            CHUNK_MAT_TRANSPARENCY = 0xA050,
+        // Always followed by percentage chunk
+        CHUNK_MAT_TRANSPARENCY = 0xA050,
 
-            // Diffuse texture channel 0
-            CHUNK_MAT_TEXTURE   = 0xA200,
+        // Diffuse texture channel 0
+        CHUNK_MAT_TEXTURE = 0xA200,
 
-            // Contains opacity information for each texel
-            CHUNK_MAT_OPACMAP = 0xA210,
+        // Contains opacity information for each texel
+        CHUNK_MAT_OPACMAP = 0xA210,
 
-            // Contains a reflection map to be used to reflect
-            // the environment. This is partially supported.
-            CHUNK_MAT_REFLMAP = 0xA220,
+        // Contains a reflection map to be used to reflect
+        // the environment. This is partially supported.
+        CHUNK_MAT_REFLMAP = 0xA220,
 
-            // Self Illumination map (emissive colors)
-            CHUNK_MAT_SELFIMAP = 0xA33d,
+        // Self Illumination map (emissive colors)
+        CHUNK_MAT_SELFIMAP = 0xA33d,
 
-            // Bumpmap. Not specified whether it is a heightmap
-            // or a normal map. Assme it is a heightmap since
-            // artist normally prefer this format.
-            CHUNK_MAT_BUMPMAP = 0xA230,
+        // Bumpmap. Not specified whether it is a heightmap
+        // or a normal map. Assme it is a heightmap since
+        // artist normally prefer this format.
+        CHUNK_MAT_BUMPMAP = 0xA230,
 
-            // Specular map. Seems to influence the specular color
-            CHUNK_MAT_SPECMAP = 0xA204,
+        // Specular map. Seems to influence the specular color
+        CHUNK_MAT_SPECMAP = 0xA204,
 
-            // Holds shininess data.
-            CHUNK_MAT_MAT_SHINMAP = 0xA33C,
+        // Holds shininess data.
+        CHUNK_MAT_MAT_SHINMAP = 0xA33C,
 
-            // Scaling in U/V direction.
-            // (need to gen separate UV coordinate set
-            // and do this by hand)
-            CHUNK_MAT_MAP_USCALE      = 0xA354,
-            CHUNK_MAT_MAP_VSCALE      = 0xA356,
+        // Scaling in U/V direction.
+        // (need to gen separate UV coordinate set
+        // and do this by hand)
+        CHUNK_MAT_MAP_USCALE = 0xA354,
+        CHUNK_MAT_MAP_VSCALE = 0xA356,
 
-            // Translation in U/V direction.
-            // (need to gen separate UV coordinate set
-            // and do this by hand)
-            CHUNK_MAT_MAP_UOFFSET     = 0xA358,
-            CHUNK_MAT_MAP_VOFFSET     = 0xA35a,
+        // Translation in U/V direction.
+        // (need to gen separate UV coordinate set
+        // and do this by hand)
+        CHUNK_MAT_MAP_UOFFSET = 0xA358,
+        CHUNK_MAT_MAP_VOFFSET = 0xA35a,
 
-            // UV-coordinates rotation around the z-axis
-            // Assumed to be in radians.
-            CHUNK_MAT_MAP_ANG = 0xA35C,
+        // UV-coordinates rotation around the z-axis
+        // Assumed to be in radians.
+        CHUNK_MAT_MAP_ANG = 0xA35C,
 
-            // Tiling flags for 3DS files
-            CHUNK_MAT_MAP_TILING = 0xa351,
+        // Tiling flags for 3DS files
+        CHUNK_MAT_MAP_TILING = 0xa351,
 
-            // Specifies the file name of a texture
-            CHUNK_MAPFILE   = 0xA300,
+        // Specifies the file name of a texture
+        CHUNK_MAPFILE = 0xA300,
 
-            // Specifies whether a materail requires two-sided rendering
-            CHUNK_MAT_TWO_SIDE = 0xA081,
+        // Specifies whether a materail requires two-sided rendering
+        CHUNK_MAT_TWO_SIDE = 0xA081,
         // ********************************************************************
 
         // Main keyframer chunk. Contains translation/rotation/scaling data
-        CHUNK_KEYFRAMER     = 0xB000,
+        CHUNK_KEYFRAMER = 0xB000,
 
         // Supported sub chunks
-        CHUNK_TRACKINFO     = 0xB002,
-        CHUNK_TRACKOBJNAME  = 0xB010,
-        CHUNK_TRACKDUMMYOBJNAME  = 0xB011,
-        CHUNK_TRACKPIVOT    = 0xB013,
-        CHUNK_TRACKPOS      = 0xB020,
-        CHUNK_TRACKROTATE   = 0xB021,
-        CHUNK_TRACKSCALE    = 0xB022,
+        CHUNK_TRACKINFO = 0xB002,
+        CHUNK_TRACKOBJNAME = 0xB010,
+        CHUNK_TRACKDUMMYOBJNAME = 0xB011,
+        CHUNK_TRACKPIVOT = 0xB013,
+        CHUNK_TRACKPOS = 0xB020,
+        CHUNK_TRACKROTATE = 0xB021,
+        CHUNK_TRACKSCALE = 0xB022,
 
         // ********************************************************************
         // Keyframes for various other stuff in the file
         // Partially ignored
-        CHUNK_AMBIENTKEY    = 0xB001,
-        CHUNK_TRACKMORPH    = 0xB026,
-        CHUNK_TRACKHIDE     = 0xB029,
-        CHUNK_OBJNUMBER     = 0xB030,
-        CHUNK_TRACKCAMERA   = 0xB003,
-        CHUNK_TRACKFOV      = 0xB023,
-        CHUNK_TRACKROLL     = 0xB024,
-        CHUNK_TRACKCAMTGT   = 0xB004,
-        CHUNK_TRACKLIGHT    = 0xB005,
-        CHUNK_TRACKLIGTGT   = 0xB006,
-        CHUNK_TRACKSPOTL    = 0xB007,
-        CHUNK_FRAMES        = 0xB008,
+        CHUNK_AMBIENTKEY = 0xB001,
+        CHUNK_TRACKMORPH = 0xB026,
+        CHUNK_TRACKHIDE = 0xB029,
+        CHUNK_OBJNUMBER = 0xB030,
+        CHUNK_TRACKCAMERA = 0xB003,
+        CHUNK_TRACKFOV = 0xB023,
+        CHUNK_TRACKROLL = 0xB024,
+        CHUNK_TRACKCAMTGT = 0xB004,
+        CHUNK_TRACKLIGHT = 0xB005,
+        CHUNK_TRACKLIGTGT = 0xB006,
+        CHUNK_TRACKSPOTL = 0xB007,
+        CHUNK_FRAMES = 0xB008,
         // ********************************************************************
 
         // light sub-chunks
-        CHUNK_DL_OFF                 = 0x4620,
-        CHUNK_DL_OUTER_RANGE         = 0x465A,
-        CHUNK_DL_INNER_RANGE         = 0x4659,
-        CHUNK_DL_MULTIPLIER          = 0x465B,
-        CHUNK_DL_EXCLUDE             = 0x4654,
-        CHUNK_DL_ATTENUATE           = 0x4625,
-        CHUNK_DL_SPOTLIGHT           = 0x4610,
+        CHUNK_DL_OFF = 0x4620,
+        CHUNK_DL_OUTER_RANGE = 0x465A,
+        CHUNK_DL_INNER_RANGE = 0x4659,
+        CHUNK_DL_MULTIPLIER = 0x465B,
+        CHUNK_DL_EXCLUDE = 0x4654,
+        CHUNK_DL_ATTENUATE = 0x4625,
+        CHUNK_DL_SPOTLIGHT = 0x4610,
 
         // camera sub-chunks
-        CHUNK_CAM_RANGES             = 0x4720
+        CHUNK_CAM_RANGES = 0x4720
     };
 };
 
 // ---------------------------------------------------------------------------
 /** Helper structure representing a 3ds mesh face */
-struct Face : public FaceWithSmoothingGroup
-{
+struct Face : public FaceWithSmoothingGroup {
 };
 
+#pragma warning(disable : 4315 )
+
 // ---------------------------------------------------------------------------
 /** Helper structure representing a texture */
 struct Texture {
     //! Default constructor
     Texture() AI_NO_EXCEPT
-    : mOffsetU  (0.0)
-    , mOffsetV  (0.0)
-    , mScaleU   (1.0)
-    , mScaleV   (1.0)
-    , mRotation (0.0)
-    , mMapMode  (aiTextureMapMode_Wrap)
-    , bPrivate()
-    , iUVSrc    (0) {
+            : mTextureBlend(0.0f),
+              mMapName(),
+              mOffsetU(0.0),
+              mOffsetV(0.0),
+              mScaleU(1.0),
+              mScaleV(1.0),
+              mRotation(0.0),
+              mMapMode(aiTextureMapMode_Wrap),
+              bPrivate(),
+              iUVSrc(0) {
         mTextureBlend = get_qnan();
     }
 
-    Texture(Texture &&other) AI_NO_EXCEPT : 
-		    mTextureBlend(std::move(other.mTextureBlend)),
-											mMapName(std::move(mMapName)),
-											mOffsetU(std::move(mOffsetU)),
-											mOffsetV(std::move(mOffsetV)),
-											mScaleU(std::move(mScaleU)),
-											mScaleV(std::move(mScaleV)),
-											mRotation(std::move(mRotation)),
-											mMapMode(std::move(mMapMode)),
-											bPrivate(std::move(bPrivate)),
-											iUVSrc(std::move(iUVSrc)) {
+    Texture(Texture &&other) AI_NO_EXCEPT : mTextureBlend(std::move(other.mTextureBlend)),
+                                            mMapName(std::move(mMapName)),
+                                            mOffsetU(std::move(mOffsetU)),
+                                            mOffsetV(std::move(mOffsetV)),
+                                            mScaleU(std::move(mScaleU)),
+                                            mScaleV(std::move(mScaleV)),
+                                            mRotation(std::move(mRotation)),
+                                            mMapMode(std::move(mMapMode)),
+                                            bPrivate(std::move(bPrivate)),
+                                            iUVSrc(std::move(iUVSrc)) {
+        // empty
+    }
+
+    Texture &operator=(Texture &&other) AI_NO_EXCEPT {
+        if (this == &other) {
+            return *this;
+        }
+
+        mTextureBlend = std::move(other.mTextureBlend);
+        mMapName = std::move(other.mMapName);
+        mOffsetU = std::move(other.mOffsetU);
+        mOffsetV = std::move(other.mOffsetV);
+        mScaleU = std::move(other.mScaleU);
+        mScaleV = std::move(other.mScaleV);
+        mRotation = std::move(other.mRotation);
+        mMapMode = std::move(other.mMapMode);
+        bPrivate = std::move(other.bPrivate);
+        iUVSrc = std::move(other.iUVSrc);
 
+        return *this;
     }
 
     //! Specifies the blend factor for the texture
@@ -381,55 +398,48 @@ struct Texture {
 
 // ---------------------------------------------------------------------------
 /** Helper structure representing a 3ds material */
-struct Material
-{
+struct Material {
     //! Default constructor has been deleted
     Material() = delete;
 
-
     //! Constructor with explicit name
-    explicit Material(const std::string &name)
-    : mName(name)
-    , mDiffuse            ( ai_real( 0.6 ), ai_real( 0.6 ), ai_real( 0.6 ) ) // FIX ... we won't want object to be black
-    , mSpecularExponent   ( ai_real( 0.0 ) )
-    , mShininessStrength  ( ai_real( 1.0 ) )
-    , mShading(Discreet3DS::Gouraud)
-    , mTransparency       ( ai_real( 1.0 ) )
-    , mBumpHeight         ( ai_real( 1.0 ) )
-    , mTwoSided           (false)
-    {
+    explicit Material(const std::string &name) :
+            mName(name), mDiffuse(ai_real(0.6), ai_real(0.6), ai_real(0.6)) // FIX ... we won't want object to be black
+            ,
+            mSpecularExponent(ai_real(0.0)),
+            mShininessStrength(ai_real(1.0)),
+            mShading(Discreet3DS::Gouraud),
+            mTransparency(ai_real(1.0)),
+            mBumpHeight(ai_real(1.0)),
+            mTwoSided(false) {
     }
 
-
-    Material(const Material &other)            = default;
+    Material(const Material &other) = default;
     Material &operator=(const Material &other) = default;
 
-
     //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
     Material(Material &&other) AI_NO_EXCEPT
-    : mName(std::move(other.mName))
-    , mDiffuse(std::move(other.mDiffuse))
-    , mSpecularExponent(std::move(other.mSpecularExponent))
-    , mShininessStrength(std::move(other.mShininessStrength))
-    , mSpecular(std::move(other.mSpecular))
-    , mAmbient(std::move(other.mAmbient))
-    , mShading(std::move(other.mShading))
-    , mTransparency(std::move(other.mTransparency))
-    , sTexDiffuse(std::move(other.sTexDiffuse))
-    , sTexOpacity(std::move(other.sTexOpacity))
-    , sTexSpecular(std::move(other.sTexSpecular))
-    , sTexReflective(std::move(other.sTexReflective))
-    , sTexBump(std::move(other.sTexBump))
-    , sTexEmissive(std::move(other.sTexEmissive))
-    , sTexShininess(std::move(other.sTexShininess))
-    , mBumpHeight(std::move(other.mBumpHeight))
-    , mEmissive(std::move(other.mEmissive))
-    , sTexAmbient(std::move(other.sTexAmbient))
-    , mTwoSided(std::move(other.mTwoSided))
-    {
+            : mName(std::move(other.mName)),
+              mDiffuse(std::move(other.mDiffuse)),
+              mSpecularExponent(std::move(other.mSpecularExponent)),
+              mShininessStrength(std::move(other.mShininessStrength)),
+              mSpecular(std::move(other.mSpecular)),
+              mAmbient(std::move(other.mAmbient)),
+              mShading(std::move(other.mShading)),
+              mTransparency(std::move(other.mTransparency)),
+              sTexDiffuse(std::move(other.sTexDiffuse)),
+              sTexOpacity(std::move(other.sTexOpacity)),
+              sTexSpecular(std::move(other.sTexSpecular)),
+              sTexReflective(std::move(other.sTexReflective)),
+              sTexBump(std::move(other.sTexBump)),
+              sTexEmissive(std::move(other.sTexEmissive)),
+              sTexShininess(std::move(other.sTexShininess)),
+              mBumpHeight(std::move(other.mBumpHeight)),
+              mEmissive(std::move(other.mEmissive)),
+              sTexAmbient(std::move(other.sTexAmbient)),
+              mTwoSided(std::move(other.mTwoSided)) {
     }
 
-
     Material &operator=(Material &&other) AI_NO_EXCEPT {
         if (this == &other) {
             return *this;
@@ -458,10 +468,8 @@ struct Material
         return *this;
     }
 
-
     virtual ~Material() {}
 
-
     //! Name of the material
     std::string mName;
     //! Diffuse color of the material
@@ -505,18 +513,15 @@ struct Material
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent a 3ds file mesh */
-struct Mesh : public MeshWithSmoothingGroups<D3DS::Face>
-{
+struct Mesh : public MeshWithSmoothingGroups<D3DS::Face> {
     //! Default constructor has been deleted
     Mesh() = delete;
 
     //! Constructor with explicit name
-    explicit Mesh(const std::string &name)
-    : mName(name)
-    {
+    explicit Mesh(const std::string &name) :
+            mName(name) {
     }
 
-
     //! Name of the mesh
     std::string mName;
 
@@ -533,62 +538,48 @@ struct Mesh : public MeshWithSmoothingGroups<D3DS::Face>
 // ---------------------------------------------------------------------------
 /** Float key - quite similar to aiVectorKey and aiQuatKey. Both are in the
     C-API, so it would be difficult to make them a template. */
-struct aiFloatKey
-{
-    double mTime;      ///< The time of this key
-    ai_real mValue;   ///< The value of this key
+struct aiFloatKey {
+    double mTime; ///< The time of this key
+    ai_real mValue; ///< The value of this key
 
 #ifdef __cplusplus
 
     // time is not compared
-    bool operator == (const aiFloatKey& o) const
-        {return o.mValue == this->mValue;}
+    bool operator==(const aiFloatKey &o) const { return o.mValue == this->mValue; }
 
-    bool operator != (const aiFloatKey& o) const
-        {return o.mValue != this->mValue;}
+    bool operator!=(const aiFloatKey &o) const { return o.mValue != this->mValue; }
 
     // Only time is compared. This operator is defined
     // for use with std::sort
-    bool operator < (const aiFloatKey& o) const
-        {return mTime < o.mTime;}
+    bool operator<(const aiFloatKey &o) const { return mTime < o.mTime; }
 
-    bool operator > (const aiFloatKey& o) const
-        {return mTime > o.mTime;}
+    bool operator>(const aiFloatKey &o) const { return mTime > o.mTime; }
 
 #endif
 };
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent a 3ds file node */
-struct Node
-{
+struct Node {
     Node() = delete;
 
-    explicit Node(const std::string &name)
-    : mParent(NULL)
-    , mName(name)
-    , mInstanceNumber(0)
-    , mHierarchyPos       (0)
-    , mHierarchyIndex     (0)
-    , mInstanceCount      (1)
-    {
-        aRotationKeys.reserve (20);
-        aPositionKeys.reserve (20);
-        aScalingKeys.reserve  (20);
+    explicit Node(const std::string &name) :
+            mParent(NULL), mName(name), mInstanceNumber(0), mHierarchyPos(0), mHierarchyIndex(0), mInstanceCount(1) {
+        aRotationKeys.reserve(20);
+        aPositionKeys.reserve(20);
+        aScalingKeys.reserve(20);
     }
 
-
-    ~Node()
-    {
-        for (unsigned int i = 0; i < mChildren.size();++i)
+    ~Node() {
+        for (unsigned int i = 0; i < mChildren.size(); ++i)
             delete mChildren[i];
     }
 
     //! Pointer to the parent node
-    Node* mParent;
+    Node *mParent;
 
     //! Holds all child nodes
-    std::vector<Node*> mChildren;
+    std::vector<Node *> mChildren;
 
     //! Name of the node
     std::string mName;
@@ -614,13 +605,12 @@ struct Node
     //! Scaling keys loaded from the file
     std::vector<aiVectorKey> aScalingKeys;
 
-
     // For target lights (spot lights and directional lights):
     // The position of the target
-    std::vector< aiVectorKey > aTargetPositionKeys;
+    std::vector<aiVectorKey> aTargetPositionKeys;
 
     // For cameras: the camera roll angle
-    std::vector< aiFloatKey > aCameraRollKeys;
+    std::vector<aiFloatKey> aCameraRollKeys;
 
     //! Pivot position loaded from the file
     aiVector3D vPivot;
@@ -630,8 +620,7 @@ struct Node
 
     //! Add a child node, setup the right parent node for it
     //! \param pc Node to be 'adopted'
-    inline Node& push_back(Node* pc)
-    {
+    inline Node &push_back(Node *pc) {
         mChildren.push_back(pc);
         pc->mParent = this;
         return *this;
@@ -639,8 +628,7 @@ struct Node
 };
 // ---------------------------------------------------------------------------
 /** Helper structure analogue to aiScene */
-struct Scene
-{
+struct Scene {
     //! List of all materials loaded
     //! NOTE: 3ds references materials globally
     std::vector<Material> mMaterials;
@@ -649,17 +637,16 @@ struct Scene
     std::vector<Mesh> mMeshes;
 
     //! List of all cameras loaded
-    std::vector<aiCamera*> mCameras;
+    std::vector<aiCamera *> mCameras;
 
     //! List of all lights loaded
-    std::vector<aiLight*> mLights;
+    std::vector<aiLight *> mLights;
 
     //! Pointer to the root node of the scene
     // --- moved to main class
     // Node* pcRootNode;
 };
 
-
 } // end of namespace D3DS
 } // end of namespace Assimp
 

code/3DS/3DSLoader.cpp

@@ -158,13 +158,13 @@ void Discreet3DSImporter::SetupProperties(const Importer* /*pImp*/)
 void Discreet3DSImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene, IOSystem* pIOHandler)
 {
-    StreamReaderLE stream(pIOHandler->Open(pFile,"rb"));
+    StreamReaderLE theStream(pIOHandler->Open(pFile,"rb"));
 
     // We should have at least one chunk
-    if (stream.GetRemainingSize() < 16) {
+    if (theStream.GetRemainingSize() < 16) {
         throw DeadlyImportError("3DS file is either empty or corrupt: " + pFile);
     }
-    this->stream = &stream;
+    this->stream = &theStream;
 
     // Allocate our temporary 3DS representation
     D3DS::Scene _scene;
@@ -599,16 +599,19 @@ void Discreet3DSImporter::InverseNodeSearch(D3DS::Node* pcNode,D3DS::Node* pcCur
 
 // ------------------------------------------------------------------------------------------------
 // Find a node with a specific name in the import hierarchy
-D3DS::Node* FindNode(D3DS::Node* root, const std::string& name)
-{
-    if (root->mName == name)
+D3DS::Node* FindNode(D3DS::Node* root, const std::string& name) {
+    if (root->mName == name) {
         return root;
+    }
+
     for (std::vector<D3DS::Node*>::iterator it = root->mChildren.begin();it != root->mChildren.end(); ++it) {
-        D3DS::Node* nd;
-        if (( nd = FindNode(*it,name)))
+        D3DS::Node *nd = FindNode(*it, name);
+        if (nullptr != nd) {
             return nd;
+        }
     }
-    return NULL;
+
+    return nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------

code/AC/ACLoader.cpp

@@ -44,25 +44,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the AC3D importer class */
 
-
-
 #ifndef ASSIMP_BUILD_NO_AC_IMPORTER
 
 // internal headers
 #include "ACLoader.h"
-#include <assimp/ParsingUtils.h>
-#include <assimp/fast_atof.h>
-#include <assimp/Subdivision.h>
 #include "Common/Importer.h"
 #include <assimp/BaseImporter.h>
-#include <assimp/Importer.hpp>
+#include <assimp/ParsingUtils.h>
+#include <assimp/Subdivision.h>
+#include <assimp/config.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
 #include <assimp/light.h>
-#include <assimp/DefaultLogger.hpp>
 #include <assimp/material.h>
 #include <assimp/scene.h>
-#include <assimp/config.h>
+#include <assimp/DefaultLogger.hpp>
 #include <assimp/IOSystem.hpp>
-#include <assimp/importerdesc.h>
+#include <assimp/Importer.hpp>
 #include <memory>
 
 using namespace Assimp;
@@ -82,116 +80,102 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // skip to the next token
-#define AI_AC_SKIP_TO_NEXT_TOKEN() \
-    if (!SkipSpaces(&buffer)) \
-    { \
+#define AI_AC_SKIP_TO_NEXT_TOKEN()                    \
+    if (!SkipSpaces(&buffer)) {                       \
         ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL"); \
-        continue; \
+        continue;                                     \
     }
 
 // ------------------------------------------------------------------------------------------------
 // read a string (may be enclosed in double quotation marks). buffer must point to "
-#define AI_AC_GET_STRING(out) \
-    if (*buffer == '\0') { \
-        throw DeadlyImportError("AC3D: Unexpected EOF in string"); \
-    } \
-    ++buffer; \
-    const char* sz = buffer; \
-    while ('\"' != *buffer) \
-    { \
-        if (IsLineEnd( *buffer )) \
-        { \
+#define AI_AC_GET_STRING(out)                                       \
+    if (*buffer == '\0') {                                          \
+        throw DeadlyImportError("AC3D: Unexpected EOF in string");  \
+    }                                                               \
+    ++buffer;                                                       \
+    const char *sz = buffer;                                        \
+    while ('\"' != *buffer) {                                       \
+        if (IsLineEnd(*buffer)) {                                   \
             ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL in string"); \
-            out = "ERROR"; \
-            break; \
-        } \
-        ++buffer; \
-    } \
-    if (IsLineEnd( *buffer ))continue; \
-    out = std::string(sz,(unsigned int)(buffer-sz)); \
+            out = "ERROR";                                          \
+            break;                                                  \
+        }                                                           \
+        ++buffer;                                                   \
+    }                                                               \
+    if (IsLineEnd(*buffer)) continue;                               \
+    out = std::string(sz, (unsigned int)(buffer - sz));             \
     ++buffer;
 
-
 // ------------------------------------------------------------------------------------------------
 // read 1 to n floats prefixed with an optional predefined identifier
-#define AI_AC_CHECKED_LOAD_FLOAT_ARRAY(name,name_length,num,out) \
-    AI_AC_SKIP_TO_NEXT_TOKEN(); \
-    if (name_length) \
-    { \
-        if (strncmp(buffer,name,name_length) || !IsSpace(buffer[name_length])) \
-        { \
-            ASSIMP_LOG_ERROR("AC3D: Unexpexted token. " name " was expected."); \
-            continue; \
-        } \
-        buffer += name_length+1; \
-    } \
-    for (unsigned int i = 0; i < num;++i) \
-    { \
-        AI_AC_SKIP_TO_NEXT_TOKEN(); \
-        buffer = fast_atoreal_move<float>(buffer,((float*)out)[i]); \
+#define AI_AC_CHECKED_LOAD_FLOAT_ARRAY(name, name_length, num, out)                \
+    AI_AC_SKIP_TO_NEXT_TOKEN();                                                    \
+    if (name_length) {                                                             \
+        if (strncmp(buffer, name, name_length) || !IsSpace(buffer[name_length])) { \
+            ASSIMP_LOG_ERROR("AC3D: Unexpexted token. " name " was expected.");    \
+            continue;                                                              \
+        }                                                                          \
+        buffer += name_length + 1;                                                 \
+    }                                                                              \
+    for (unsigned int _i = 0; _i < num; ++_i) {                                    \
+        AI_AC_SKIP_TO_NEXT_TOKEN();                                                \
+        buffer = fast_atoreal_move<float>(buffer, ((float *)out)[_i]);             \
     }
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-AC3DImporter::AC3DImporter()
-    : buffer(),
-    configSplitBFCull(),
-    configEvalSubdivision(),
-    mNumMeshes(),
-    mLights(),
-    lights(),
-    groups(),
-    polys(),
-    worlds()
-{
+AC3DImporter::AC3DImporter() :
+        buffer(),
+        configSplitBFCull(),
+        configEvalSubdivision(),
+        mNumMeshes(),
+        mLights(),
+        mLightsCounter(0),
+        mGroupsCounter(0),
+        mPolysCounter(0),
+        mWorldsCounter(0) {
     // nothing to be done here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-AC3DImporter::~AC3DImporter()
-{
+AC3DImporter::~AC3DImporter() {
     // nothing to be done here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool AC3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
+bool AC3DImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const {
     std::string extension = GetExtension(pFile);
 
     // fixme: are acc and ac3d *really* used? Some sources say they are
-    if(extension == "ac" || extension == "ac3d" || extension == "acc") {
+    if (extension == "ac" || extension == "ac3d" || extension == "acc") {
         return true;
     }
     if (!extension.length() || checkSig) {
         uint32_t token = AI_MAKE_MAGIC("AC3D");
-        return CheckMagicToken(pIOHandler,pFile,&token,1,0);
+        return CheckMagicToken(pIOHandler, pFile, &token, 1, 0);
     }
     return false;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Loader meta information
-const aiImporterDesc* AC3DImporter::GetInfo () const
-{
+const aiImporterDesc *AC3DImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a pointer to the next line from the file
-bool AC3DImporter::GetNextLine( )
-{
+bool AC3DImporter::GetNextLine() {
     SkipLine(&buffer);
     return SkipSpaces(&buffer);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Parse an object section in an AC file
-void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
-{
-    if (!TokenMatch(buffer,"OBJECT",6))
+void AC3DImporter::LoadObjectSection(std::vector<Object> &objects) {
+    if (!TokenMatch(buffer, "OBJECT", 6))
         return;
 
     SkipSpaces(&buffer);
@@ -199,145 +183,109 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
     ++mNumMeshes;
 
     objects.push_back(Object());
-    Object& obj = objects.back();
+    Object &obj = objects.back();
 
-    aiLight* light = NULL;
-    if (!ASSIMP_strincmp(buffer,"light",5))
-    {
+    aiLight *light = NULL;
+    if (!ASSIMP_strincmp(buffer, "light", 5)) {
         // This is a light source. Add it to the list
         mLights->push_back(light = new aiLight());
 
         // Return a point light with no attenuation
         light->mType = aiLightSource_POINT;
-        light->mColorDiffuse = light->mColorSpecular = aiColor3D(1.f,1.f,1.f);
+        light->mColorDiffuse = light->mColorSpecular = aiColor3D(1.f, 1.f, 1.f);
         light->mAttenuationConstant = 1.f;
 
         // Generate a default name for both the light source and the node
         // FIXME - what's the right way to print a size_t? Is 'zu' universally available? stick with the safe version.
-        light->mName.length = ::ai_snprintf(light->mName.data, MAXLEN, "ACLight_%i",static_cast<unsigned int>(mLights->size())-1);
-        obj.name = std::string( light->mName.data );
+        light->mName.length = ::ai_snprintf(light->mName.data, MAXLEN, "ACLight_%i", static_cast<unsigned int>(mLights->size()) - 1);
+        obj.name = std::string(light->mName.data);
 
         ASSIMP_LOG_DEBUG("AC3D: Light source encountered");
         obj.type = Object::Light;
-    }
-    else if (!ASSIMP_strincmp(buffer,"group",5))
-    {
+    } else if (!ASSIMP_strincmp(buffer, "group", 5)) {
         obj.type = Object::Group;
-    }
-    else if (!ASSIMP_strincmp(buffer,"world",5))
-    {
+    } else if (!ASSIMP_strincmp(buffer, "world", 5)) {
         obj.type = Object::World;
-    }
-    else obj.type = Object::Poly;
-    while (GetNextLine())
-    {
-        if (TokenMatch(buffer,"kids",4))
-        {
+    } else
+        obj.type = Object::Poly;
+    while (GetNextLine()) {
+        if (TokenMatch(buffer, "kids", 4)) {
             SkipSpaces(&buffer);
-            unsigned int num = strtoul10(buffer,&buffer);
+            unsigned int num = strtoul10(buffer, &buffer);
             GetNextLine();
-            if (num)
-            {
+            if (num) {
                 // load the children of this object recursively
                 obj.children.reserve(num);
                 for (unsigned int i = 0; i < num; ++i)
                     LoadObjectSection(obj.children);
             }
             return;
-        }
-        else if (TokenMatch(buffer,"name",4))
-        {
+        } else if (TokenMatch(buffer, "name", 4)) {
             SkipSpaces(&buffer);
             AI_AC_GET_STRING(obj.name);
 
             // If this is a light source, we'll also need to store
             // the name of the node in it.
-            if (light)
-            {
+            if (light) {
                 light->mName.Set(obj.name);
             }
-        }
-        else if (TokenMatch(buffer,"texture",7))
-        {
+        } else if (TokenMatch(buffer, "texture", 7)) {
             SkipSpaces(&buffer);
             AI_AC_GET_STRING(obj.texture);
-        }
-        else if (TokenMatch(buffer,"texrep",6))
-        {
+        } else if (TokenMatch(buffer, "texrep", 6)) {
             SkipSpaces(&buffer);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,2,&obj.texRepeat);
+            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("", 0, 2, &obj.texRepeat);
             if (!obj.texRepeat.x || !obj.texRepeat.y)
-                obj.texRepeat = aiVector2D (1.f,1.f);
-        }
-        else if (TokenMatch(buffer,"texoff",6))
-        {
+                obj.texRepeat = aiVector2D(1.f, 1.f);
+        } else if (TokenMatch(buffer, "texoff", 6)) {
             SkipSpaces(&buffer);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,2,&obj.texOffset);
-        }
-        else if (TokenMatch(buffer,"rot",3))
-        {
+            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("", 0, 2, &obj.texOffset);
+        } else if (TokenMatch(buffer, "rot", 3)) {
             SkipSpaces(&buffer);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,9,&obj.rotation);
-        }
-        else if (TokenMatch(buffer,"loc",3))
-        {
+            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("", 0, 9, &obj.rotation);
+        } else if (TokenMatch(buffer, "loc", 3)) {
             SkipSpaces(&buffer);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,3,&obj.translation);
-        }
-        else if (TokenMatch(buffer,"subdiv",6))
-        {
+            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("", 0, 3, &obj.translation);
+        } else if (TokenMatch(buffer, "subdiv", 6)) {
             SkipSpaces(&buffer);
-            obj.subDiv = strtoul10(buffer,&buffer);
-        }
-        else if (TokenMatch(buffer,"crease",6))
-        {
+            obj.subDiv = strtoul10(buffer, &buffer);
+        } else if (TokenMatch(buffer, "crease", 6)) {
             SkipSpaces(&buffer);
             obj.crease = fast_atof(buffer);
-        }
-        else if (TokenMatch(buffer,"numvert",7))
-        {
+        } else if (TokenMatch(buffer, "numvert", 7)) {
             SkipSpaces(&buffer);
 
-            unsigned int t = strtoul10(buffer,&buffer);
+            unsigned int t = strtoul10(buffer, &buffer);
             if (t >= AI_MAX_ALLOC(aiVector3D)) {
                 throw DeadlyImportError("AC3D: Too many vertices, would run out of memory");
             }
             obj.vertices.reserve(t);
-            for (unsigned int i = 0; i < t;++i)
-            {
-                if (!GetNextLine())
-                {
+            for (unsigned int i = 0; i < t; ++i) {
+                if (!GetNextLine()) {
                     ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: not all vertices have been parsed yet");
                     break;
-                }
-                else if (!IsNumeric(*buffer))
-                {
+                } else if (!IsNumeric(*buffer)) {
                     ASSIMP_LOG_ERROR("AC3D: Unexpected token: not all vertices have been parsed yet");
                     --buffer; // make sure the line is processed a second time
                     break;
                 }
                 obj.vertices.push_back(aiVector3D());
-                aiVector3D& v = obj.vertices.back();
-                AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,3,&v.x);
+                aiVector3D &v = obj.vertices.back();
+                AI_AC_CHECKED_LOAD_FLOAT_ARRAY("", 0, 3, &v.x);
             }
-        }
-        else if (TokenMatch(buffer,"numsurf",7))
-        {
+        } else if (TokenMatch(buffer, "numsurf", 7)) {
             SkipSpaces(&buffer);
 
             bool Q3DWorkAround = false;
 
-            const unsigned int t = strtoul10(buffer,&buffer);
+            const unsigned int t = strtoul10(buffer, &buffer);
             obj.surfaces.reserve(t);
-            for (unsigned int i = 0; i < t;++i)
-            {
+            for (unsigned int i = 0; i < t; ++i) {
                 GetNextLine();
-                if (!TokenMatch(buffer,"SURF",4))
-                {
+                if (!TokenMatch(buffer, "SURF", 4)) {
                     // FIX: this can occur for some files - Quick 3D for
                     // example writes no surf chunks
-                    if (!Q3DWorkAround)
-                    {
+                    if (!Q3DWorkAround) {
                         ASSIMP_LOG_WARN("AC3D: SURF token was expected");
                         ASSIMP_LOG_DEBUG("Continuing with Quick3D Workaround enabled");
                     }
@@ -348,27 +296,20 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
                 }
                 SkipSpaces(&buffer);
                 obj.surfaces.push_back(Surface());
-                Surface& surf = obj.surfaces.back();
+                Surface &surf = obj.surfaces.back();
                 surf.flags = strtoul_cppstyle(buffer);
 
-                while (1)
-                {
-                    if(!GetNextLine())
-                    {
+                while (1) {
+                    if (!GetNextLine()) {
                         throw DeadlyImportError("AC3D: Unexpected EOF: surface is incomplete");
                     }
-                    if (TokenMatch(buffer,"mat",3))
-                    {
+                    if (TokenMatch(buffer, "mat", 3)) {
                         SkipSpaces(&buffer);
                         surf.mat = strtoul10(buffer);
-                    }
-                    else if (TokenMatch(buffer,"refs",4))
-                    {
+                    } else if (TokenMatch(buffer, "refs", 4)) {
                         // --- see fix notes above
-                        if (Q3DWorkAround)
-                        {
-                            if (!surf.entries.empty())
-                            {
+                        if (Q3DWorkAround) {
+                            if (!surf.entries.empty()) {
                                 buffer -= 6;
                                 break;
                             }
@@ -380,23 +321,19 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
 
                         obj.numRefs += m;
 
-                        for (unsigned int k = 0; k < m; ++k)
-                        {
-                            if(!GetNextLine())
-                            {
+                        for (unsigned int k = 0; k < m; ++k) {
+                            if (!GetNextLine()) {
                                 ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: surface references are incomplete");
                                 break;
                             }
                             surf.entries.push_back(Surface::SurfaceEntry());
-                            Surface::SurfaceEntry& entry = surf.entries.back();
+                            Surface::SurfaceEntry &entry = surf.entries.back();
 
-                            entry.first = strtoul10(buffer,&buffer);
+                            entry.first = strtoul10(buffer, &buffer);
                             SkipSpaces(&buffer);
-                            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,2,&entry.second);
+                            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("", 0, 2, &entry.second);
                         }
-                    }
-                    else
-                    {
+                    } else {
 
                         --buffer; // make sure the line is processed a second time
                         break;
@@ -410,65 +347,57 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
 
 // ------------------------------------------------------------------------------------------------
 // Convert a material from AC3DImporter::Material to aiMaterial
-void AC3DImporter::ConvertMaterial(const Object& object,
-    const Material& matSrc,
-    aiMaterial& matDest)
-{
+void AC3DImporter::ConvertMaterial(const Object &object,
+        const Material &matSrc,
+        aiMaterial &matDest) {
     aiString s;
 
-    if (matSrc.name.length())
-    {
+    if (matSrc.name.length()) {
         s.Set(matSrc.name);
-        matDest.AddProperty(&s,AI_MATKEY_NAME);
+        matDest.AddProperty(&s, AI_MATKEY_NAME);
     }
-    if (object.texture.length())
-    {
+    if (object.texture.length()) {
         s.Set(object.texture);
-        matDest.AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));
+        matDest.AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
 
         // UV transformation
         if (1.f != object.texRepeat.x || 1.f != object.texRepeat.y ||
-            object.texOffset.x        || object.texOffset.y)
-        {
+                object.texOffset.x || object.texOffset.y) {
             aiUVTransform transform;
             transform.mScaling = object.texRepeat;
             transform.mTranslation = object.texOffset;
-            matDest.AddProperty(&transform,1,AI_MATKEY_UVTRANSFORM_DIFFUSE(0));
+            matDest.AddProperty(&transform, 1, AI_MATKEY_UVTRANSFORM_DIFFUSE(0));
         }
     }
 
-    matDest.AddProperty<aiColor3D>(&matSrc.rgb,1, AI_MATKEY_COLOR_DIFFUSE);
-    matDest.AddProperty<aiColor3D>(&matSrc.amb,1, AI_MATKEY_COLOR_AMBIENT);
-    matDest.AddProperty<aiColor3D>(&matSrc.emis,1,AI_MATKEY_COLOR_EMISSIVE);
-    matDest.AddProperty<aiColor3D>(&matSrc.spec,1,AI_MATKEY_COLOR_SPECULAR);
+    matDest.AddProperty<aiColor3D>(&matSrc.rgb, 1, AI_MATKEY_COLOR_DIFFUSE);
+    matDest.AddProperty<aiColor3D>(&matSrc.amb, 1, AI_MATKEY_COLOR_AMBIENT);
+    matDest.AddProperty<aiColor3D>(&matSrc.emis, 1, AI_MATKEY_COLOR_EMISSIVE);
+    matDest.AddProperty<aiColor3D>(&matSrc.spec, 1, AI_MATKEY_COLOR_SPECULAR);
 
     int n;
-    if (matSrc.shin)
-    {
+    if (matSrc.shin) {
         n = aiShadingMode_Phong;
-        matDest.AddProperty<float>(&matSrc.shin,1,AI_MATKEY_SHININESS);
-    }
-    else n = aiShadingMode_Gouraud;
-    matDest.AddProperty<int>(&n,1,AI_MATKEY_SHADING_MODEL);
+        matDest.AddProperty<float>(&matSrc.shin, 1, AI_MATKEY_SHININESS);
+    } else
+        n = aiShadingMode_Gouraud;
+    matDest.AddProperty<int>(&n, 1, AI_MATKEY_SHADING_MODEL);
 
     float f = 1.f - matSrc.trans;
-    matDest.AddProperty<float>(&f,1,AI_MATKEY_OPACITY);
+    matDest.AddProperty<float>(&f, 1, AI_MATKEY_OPACITY);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Converts the loaded data to the internal verbose representation
-aiNode* AC3DImporter::ConvertObjectSection(Object& object,
-    std::vector<aiMesh*>& meshes,
-    std::vector<aiMaterial*>& outMaterials,
-    const std::vector<Material>& materials,
-    aiNode* parent)
-{
-    aiNode* node = new aiNode();
+aiNode *AC3DImporter::ConvertObjectSection(Object &object,
+        std::vector<aiMesh *> &meshes,
+        std::vector<aiMaterial *> &outMaterials,
+        const std::vector<Material> &materials,
+        aiNode *parent) {
+    aiNode *node = new aiNode();
     node->mParent = parent;
-    if (object.vertices.size())
-    {
-        if (!object.surfaces.size() || !object.numRefs)
-        {
+    if (object.vertices.size()) {
+        if (!object.surfaces.size() || !object.numRefs) {
             /* " An object with 7 vertices (no surfaces, no materials defined).
                  This is a good way of getting point data into AC3D.
                  The Vertex->create convex-surface/object can be used on these
@@ -479,17 +408,16 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
              */
 
             ASSIMP_LOG_INFO("AC3D: No surfaces defined in object definition, "
-                "a point list is returned");
+                            "a point list is returned");
 
             meshes.push_back(new aiMesh());
-            aiMesh* mesh = meshes.back();
+            aiMesh *mesh = meshes.back();
 
             mesh->mNumFaces = mesh->mNumVertices = (unsigned int)object.vertices.size();
-            aiFace* faces = mesh->mFaces = new aiFace[mesh->mNumFaces];
-            aiVector3D* verts = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+            aiFace *faces = mesh->mFaces = new aiFace[mesh->mNumFaces];
+            aiVector3D *verts = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
 
-            for (unsigned int i = 0; i < mesh->mNumVertices;++i,++faces,++verts)
-            {
+            for (unsigned int i = 0; i < mesh->mNumVertices; ++i, ++faces, ++verts) {
                 *verts = object.vertices[i];
                 faces->mNumIndices = 1;
                 faces->mIndices = new unsigned int[1];
@@ -502,86 +430,77 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
             mesh->mMaterialIndex = 0;
             outMaterials.push_back(new aiMaterial());
             ConvertMaterial(object, materials[0], *outMaterials.back());
-        }
-        else
-        {
+        } else {
             // need to generate one or more meshes for this object.
             // find out how many different materials we have
-            typedef std::pair< unsigned int, unsigned int > IntPair;
-            typedef std::vector< IntPair > MatTable;
-            MatTable needMat(materials.size(),IntPair(0,0));
+            typedef std::pair<unsigned int, unsigned int> IntPair;
+            typedef std::vector<IntPair> MatTable;
+            MatTable needMat(materials.size(), IntPair(0, 0));
 
-            std::vector<Surface>::iterator it,end = object.surfaces.end();
-            std::vector<Surface::SurfaceEntry>::iterator it2,end2;
+            std::vector<Surface>::iterator it, end = object.surfaces.end();
+            std::vector<Surface::SurfaceEntry>::iterator it2, end2;
 
-            for (it = object.surfaces.begin(); it != end; ++it)
-            {
+            for (it = object.surfaces.begin(); it != end; ++it) {
                 unsigned int idx = (*it).mat;
-                if (idx >= needMat.size())
-                {
+                if (idx >= needMat.size()) {
                     ASSIMP_LOG_ERROR("AC3D: material index is out of range");
                     idx = 0;
                 }
-                if ((*it).entries.empty())
-                {
+                if ((*it).entries.empty()) {
                     ASSIMP_LOG_WARN("AC3D: surface her zero vertex references");
                 }
 
                 // validate all vertex indices to make sure we won't crash here
-                for (it2  = (*it).entries.begin(),
-                     end2 = (*it).entries.end(); it2 != end2; ++it2)
-                {
-                    if ((*it2).first >= object.vertices.size())
-                    {
+                for (it2 = (*it).entries.begin(),
+                    end2 = (*it).entries.end();
+                        it2 != end2; ++it2) {
+                    if ((*it2).first >= object.vertices.size()) {
                         ASSIMP_LOG_WARN("AC3D: Invalid vertex reference");
                         (*it2).first = 0;
                     }
                 }
 
-                if (!needMat[idx].first)++node->mNumMeshes;
+                if (!needMat[idx].first) ++node->mNumMeshes;
 
-                switch ((*it).flags & 0xf)
-                {
-                    // closed line
-                case 0x1:
+                switch ((*it).flags & 0xf) {
+                        // closed line
+                    case 0x1:
 
-                    needMat[idx].first  += (unsigned int)(*it).entries.size();
-                    needMat[idx].second += (unsigned int)(*it).entries.size()<<1u;
-                    break;
+                        needMat[idx].first += (unsigned int)(*it).entries.size();
+                        needMat[idx].second += (unsigned int)(*it).entries.size() << 1u;
+                        break;
 
-                    // unclosed line
-                case 0x2:
+                        // unclosed line
+                    case 0x2:
 
-                    needMat[idx].first  += (unsigned int)(*it).entries.size()-1;
-                    needMat[idx].second += ((unsigned int)(*it).entries.size()-1)<<1u;
-                    break;
+                        needMat[idx].first += (unsigned int)(*it).entries.size() - 1;
+                        needMat[idx].second += ((unsigned int)(*it).entries.size() - 1) << 1u;
+                        break;
 
-                    // 0 == polygon, else unknown
-                default:
+                        // 0 == polygon, else unknown
+                    default:
 
-                    if ((*it).flags & 0xf)
-                    {
-                        ASSIMP_LOG_WARN("AC3D: The type flag of a surface is unknown");
-                        (*it).flags &= ~(0xf);
-                    }
+                        if ((*it).flags & 0xf) {
+                            ASSIMP_LOG_WARN("AC3D: The type flag of a surface is unknown");
+                            (*it).flags &= ~(0xf);
+                        }
 
-                    // the number of faces increments by one, the number
-                    // of vertices by surface.numref.
-                    needMat[idx].first++;
-                    needMat[idx].second += (unsigned int)(*it).entries.size();
+                        // the number of faces increments by one, the number
+                        // of vertices by surface.numref.
+                        needMat[idx].first++;
+                        needMat[idx].second += (unsigned int)(*it).entries.size();
                 };
             }
-            unsigned int* pip = node->mMeshes = new unsigned int[node->mNumMeshes];
+            unsigned int *pip = node->mMeshes = new unsigned int[node->mNumMeshes];
             unsigned int mat = 0;
             const size_t oldm = meshes.size();
             for (MatTable::const_iterator cit = needMat.begin(), cend = needMat.end();
-                cit != cend; ++cit, ++mat)
-            {
-                if (!(*cit).first)continue;
+                    cit != cend; ++cit, ++mat) {
+                if (!(*cit).first) continue;
 
                 // allocate a new aiMesh object
                 *pip++ = (unsigned int)meshes.size();
-                aiMesh* mesh = new aiMesh();
+                aiMesh *mesh = new aiMesh();
                 meshes.push_back(mesh);
 
                 mesh->mMaterialIndex = (unsigned int)outMaterials.size();
@@ -595,7 +514,7 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
                 } else if (mesh->mNumFaces > AI_MAX_ALLOC(aiFace)) {
                     throw DeadlyImportError("AC3D: Too many faces, would run out of memory");
                 }
-                aiFace* faces = mesh->mFaces = new aiFace[mesh->mNumFaces];
+                aiFace *faces = mesh->mFaces = new aiFace[mesh->mNumFaces];
 
                 mesh->mNumVertices = (*cit).second;
                 if (mesh->mNumVertices == 0) {
@@ -603,35 +522,29 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
                 } else if (mesh->mNumVertices > AI_MAX_ALLOC(aiVector3D)) {
                     throw DeadlyImportError("AC3D: Too many vertices, would run out of memory");
                 }
-                aiVector3D* vertices = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+                aiVector3D *vertices = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
                 unsigned int cur = 0;
 
                 // allocate UV coordinates, but only if the texture name for the
                 // surface is not empty
-                aiVector3D* uv = NULL;
-                if(object.texture.length())
-                {
+                aiVector3D *uv = NULL;
+                if (object.texture.length()) {
                     uv = mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
                     mesh->mNumUVComponents[0] = 2;
                 }
 
-                for (it = object.surfaces.begin(); it != end; ++it)
-                {
-                    if (mat == (*it).mat)
-                    {
-                        const Surface& src = *it;
+                for (it = object.surfaces.begin(); it != end; ++it) {
+                    if (mat == (*it).mat) {
+                        const Surface &src = *it;
 
                         // closed polygon
                         unsigned int type = (*it).flags & 0xf;
-                        if (!type)
-                        {
-                            aiFace& face = *faces++;
-                            if((face.mNumIndices = (unsigned int)src.entries.size()))
-                            {
+                        if (!type) {
+                            aiFace &face = *faces++;
+                            if ((face.mNumIndices = (unsigned int)src.entries.size())) {
                                 face.mIndices = new unsigned int[face.mNumIndices];
-                                for (unsigned int i = 0; i < face.mNumIndices;++i,++vertices)
-                                {
-                                    const Surface::SurfaceEntry& entry = src.entries[i];
+                                for (unsigned int i = 0; i < face.mNumIndices; ++i, ++vertices) {
+                                    const Surface::SurfaceEntry &entry = src.entries[i];
                                     face.mIndices[i] = cur++;
 
                                     // copy vertex positions
@@ -640,28 +553,23 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
                                     }
                                     *vertices = object.vertices[entry.first] + object.translation;
 
-
                                     // copy texture coordinates
-                                    if (uv)
-                                    {
-                                        uv->x =  entry.second.x;
-                                        uv->y =  entry.second.y;
+                                    if (uv) {
+                                        uv->x = entry.second.x;
+                                        uv->y = entry.second.y;
                                         ++uv;
                                     }
                                 }
                             }
-                        }
-                        else
-                        {
+                        } else {
 
-                            it2  = (*it).entries.begin();
+                            it2 = (*it).entries.begin();
 
                             // either a closed or an unclosed line
                             unsigned int tmp = (unsigned int)(*it).entries.size();
-                            if (0x2 == type)--tmp;
-                            for (unsigned int m = 0; m < tmp;++m)
-                            {
-                                aiFace& face = *faces++;
+                            if (0x2 == type) --tmp;
+                            for (unsigned int m = 0; m < tmp; ++m) {
+                                aiFace &face = *faces++;
 
                                 face.mNumIndices = 2;
                                 face.mIndices = new unsigned int[2];
@@ -669,35 +577,31 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
                                 face.mIndices[1] = cur++;
 
                                 // copy vertex positions
-                                if (it2 == (*it).entries.end() ) {
+                                if (it2 == (*it).entries.end()) {
                                     throw DeadlyImportError("AC3D: Bad line");
                                 }
                                 ai_assert((*it2).first < object.vertices.size());
                                 *vertices++ = object.vertices[(*it2).first];
 
                                 // copy texture coordinates
-                                if (uv)
-                                {
-                                    uv->x =  (*it2).second.x;
-                                    uv->y =  (*it2).second.y;
+                                if (uv) {
+                                    uv->x = (*it2).second.x;
+                                    uv->y = (*it2).second.y;
                                     ++uv;
                                 }
 
-
-                                if (0x1 == type && tmp-1 == m)
-                                {
+                                if (0x1 == type && tmp - 1 == m) {
                                     // if this is a closed line repeat its beginning now
-                                    it2  = (*it).entries.begin();
-                                }
-                                else ++it2;
+                                    it2 = (*it).entries.begin();
+                                } else
+                                    ++it2;
 
                                 // second point
                                 *vertices++ = object.vertices[(*it2).first];
 
-                                if (uv)
-                                {
-                                    uv->x =  (*it2).second.x;
-                                    uv->y =  (*it2).second.y;
+                                if (uv) {
+                                    uv->x = (*it2).second.x;
+                                    uv->y = (*it2).second.y;
                                     ++uv;
                                 }
                             }
@@ -709,20 +613,18 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
             // Now apply catmull clark subdivision if necessary. We split meshes into
             // materials which is not done by AC3D during smoothing, so we need to
             // collect all meshes using the same material group.
-            if (object.subDiv)  {
+            if (object.subDiv) {
                 if (configEvalSubdivision) {
                     std::unique_ptr<Subdivider> div(Subdivider::Create(Subdivider::CATMULL_CLARKE));
-                    ASSIMP_LOG_INFO("AC3D: Evaluating subdivision surface: "+object.name);
+                    ASSIMP_LOG_INFO("AC3D: Evaluating subdivision surface: " + object.name);
 
-                    std::vector<aiMesh*> cpy(meshes.size()-oldm,NULL);
-                    div->Subdivide(&meshes[oldm],cpy.size(),&cpy.front(),object.subDiv,true);
-                    std::copy(cpy.begin(),cpy.end(),meshes.begin()+oldm);
+                    std::vector<aiMesh *> cpy(meshes.size() - oldm, NULL);
+                    div->Subdivide(&meshes[oldm], cpy.size(), &cpy.front(), object.subDiv, true);
+                    std::copy(cpy.begin(), cpy.end(), meshes.begin() + oldm);
 
                     // previous meshes are deleted vy Subdivide().
-                }
-                else {
-                    ASSIMP_LOG_INFO("AC3D: Letting the subdivision surface untouched due to my configuration: "
-                        +object.name);
+                } else {
+                    ASSIMP_LOG_INFO("AC3D: Letting the subdivision surface untouched due to my configuration: " + object.name);
                 }
             }
         }
@@ -730,48 +632,42 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
 
     if (object.name.length())
         node->mName.Set(object.name);
-    else
-    {
+    else {
         // generate a name depending on the type of the node
-        switch (object.type)
-        {
-        case Object::Group:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACGroup_%i",groups++);
-            break;
-        case Object::Poly:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACPoly_%i",polys++);
-            break;
-        case Object::Light:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACLight_%i",lights++);
-            break;
-
-            // there shouldn't be more than one world, but we don't care
-        case Object::World:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACWorld_%i",worlds++);
-            break;
+        switch (object.type) {
+            case Object::Group:
+                node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACGroup_%i", mGroupsCounter++);
+                break;
+            case Object::Poly:
+                node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACPoly_%i", mPolysCounter++);
+                break;
+            case Object::Light:
+                node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACLight_%i", mLightsCounter++);
+                break;
+
+                // there shouldn't be more than one world, but we don't care
+            case Object::World:
+                node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACWorld_%i", mWorldsCounter++);
+                break;
         }
     }
 
-
     // setup the local transformation matrix of the object
     // compute the transformation offset to the parent node
-    node->mTransformation = aiMatrix4x4 ( object.rotation );
+    node->mTransformation = aiMatrix4x4(object.rotation);
 
-    if (object.type == Object::Group || !object.numRefs)
-    {
+    if (object.type == Object::Group || !object.numRefs) {
         node->mTransformation.a4 = object.translation.x;
         node->mTransformation.b4 = object.translation.y;
         node->mTransformation.c4 = object.translation.z;
     }
 
     // add children to the object
-    if (object.children.size())
-    {
+    if (object.children.size()) {
         node->mNumChildren = (unsigned int)object.children.size();
-        node->mChildren = new aiNode*[node->mNumChildren];
-        for (unsigned int i = 0; i < node->mNumChildren;++i)
-        {
-            node->mChildren[i] = ConvertObjectSection(object.children[i],meshes,outMaterials,materials,node);
+        node->mChildren = new aiNode *[node->mNumChildren];
+        for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+            node->mChildren[i] = ConvertObjectSection(object.children[i], meshes, outMaterials, materials, node);
         }
     }
 
@@ -779,40 +675,38 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
 }
 
 // ------------------------------------------------------------------------------------------------
-void AC3DImporter::SetupProperties(const Importer* pImp)
-{
-    configSplitBFCull = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL,1) ? true : false;
-    configEvalSubdivision =  pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION,1) ? true : false;
+void AC3DImporter::SetupProperties(const Importer *pImp) {
+    configSplitBFCull = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL, 1) ? true : false;
+    configEvalSubdivision = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION, 1) ? true : false;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void AC3DImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+void AC3DImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if( file.get() == NULL)
-        throw DeadlyImportError( "Failed to open AC3D file " + pFile + ".");
+    if (file.get() == NULL)
+        throw DeadlyImportError("Failed to open AC3D file " + pFile + ".");
 
     // allocate storage and copy the contents of the file to a memory buffer
     std::vector<char> mBuffer2;
-    TextFileToBuffer(file.get(),mBuffer2);
+    TextFileToBuffer(file.get(), mBuffer2);
 
     buffer = &mBuffer2[0];
     mNumMeshes = 0;
 
-    lights = polys = worlds = groups = 0;
+    mLightsCounter = mPolysCounter = mWorldsCounter = mGroupsCounter = 0;
 
-    if (::strncmp(buffer,"AC3D",4)) {
+    if (::strncmp(buffer, "AC3D", 4)) {
         throw DeadlyImportError("AC3D: No valid AC3D file, magic sequence not found");
     }
 
     // print the file format version to the console
-    unsigned int version = HexDigitToDecimal( buffer[4] );
+    unsigned int version = HexDigitToDecimal(buffer[4]);
     char msg[3];
-    ASSIMP_itoa10(msg,3,version);
+    ASSIMP_itoa10(msg, 3, version);
     ASSIMP_LOG_INFO_F("AC3D file format version: ", msg);
 
     std::vector<Material> materials;
@@ -821,89 +715,81 @@ void AC3DImporter::InternReadFile( const std::string& pFile,
     std::vector<Object> rootObjects;
     rootObjects.reserve(5);
 
-    std::vector<aiLight*> lights;
-    mLights = & lights;
+    std::vector<aiLight *> lights;
+    mLights = &lights;
 
-    while (GetNextLine())
-    {
-        if (TokenMatch(buffer,"MATERIAL",8))
-        {
+    while (GetNextLine()) {
+        if (TokenMatch(buffer, "MATERIAL", 8)) {
             materials.push_back(Material());
-            Material& mat = materials.back();
+            Material &mat = materials.back();
 
             // manually parse the material ... sscanf would use the buldin atof ...
             // Format: (name) rgb %f %f %f  amb %f %f %f  emis %f %f %f  spec %f %f %f  shi %d  trans %f
 
             AI_AC_SKIP_TO_NEXT_TOKEN();
-            if ('\"' == *buffer)
-            {
+            if ('\"' == *buffer) {
                 AI_AC_GET_STRING(mat.name);
                 AI_AC_SKIP_TO_NEXT_TOKEN();
             }
 
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("rgb",3,3,&mat.rgb);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("amb",3,3,&mat.amb);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("emis",4,3,&mat.emis);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("spec",4,3,&mat.spec);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("shi",3,1,&mat.shin);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("trans",5,1,&mat.trans);
+            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("rgb", 3, 3, &mat.rgb);
+            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("amb", 3, 3, &mat.amb);
+            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("emis", 4, 3, &mat.emis);
+            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("spec", 4, 3, &mat.spec);
+            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("shi", 3, 1, &mat.shin);
+            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("trans", 5, 1, &mat.trans);
         }
         LoadObjectSection(rootObjects);
     }
 
-    if (rootObjects.empty() || !mNumMeshes)
-    {
+    if (rootObjects.empty() || !mNumMeshes) {
         throw DeadlyImportError("AC3D: No meshes have been loaded");
     }
-    if (materials.empty())
-    {
+    if (materials.empty()) {
         ASSIMP_LOG_WARN("AC3D: No material has been found");
         materials.push_back(Material());
     }
 
-    mNumMeshes += (mNumMeshes>>2u) + 1;
-    std::vector<aiMesh*> meshes;
+    mNumMeshes += (mNumMeshes >> 2u) + 1;
+    std::vector<aiMesh *> meshes;
     meshes.reserve(mNumMeshes);
 
-    std::vector<aiMaterial*> omaterials;
+    std::vector<aiMaterial *> omaterials;
     materials.reserve(mNumMeshes);
 
     // generate a dummy root if there are multiple objects on the top layer
-    Object* root;
+    Object *root;
     if (1 == rootObjects.size())
         root = &rootObjects[0];
-    else
-    {
+    else {
         root = new Object();
     }
 
     // now convert the imported stuff to our output data structure
-    pScene->mRootNode = ConvertObjectSection(*root,meshes,omaterials,materials);
-    if (1 != rootObjects.size())delete root;
+    pScene->mRootNode = ConvertObjectSection(*root, meshes, omaterials, materials);
+    if (1 != rootObjects.size()) delete root;
 
-    if (!::strncmp( pScene->mRootNode->mName.data, "Node", 4))
+    if (!::strncmp(pScene->mRootNode->mName.data, "Node", 4))
         pScene->mRootNode->mName.Set("<AC3DWorld>");
 
     // copy meshes
-    if (meshes.empty())
-    {
+    if (meshes.empty()) {
         throw DeadlyImportError("An unknown error occurred during converting");
     }
     pScene->mNumMeshes = (unsigned int)meshes.size();
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-    ::memcpy(pScene->mMeshes,&meshes[0],pScene->mNumMeshes*sizeof(void*));
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+    ::memcpy(pScene->mMeshes, &meshes[0], pScene->mNumMeshes * sizeof(void *));
 
     // copy materials
     pScene->mNumMaterials = (unsigned int)omaterials.size();
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
-    ::memcpy(pScene->mMaterials,&omaterials[0],pScene->mNumMaterials*sizeof(void*));
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+    ::memcpy(pScene->mMaterials, &omaterials[0], pScene->mNumMaterials * sizeof(void *));
 
     // copy lights
     pScene->mNumLights = (unsigned int)lights.size();
-    if (lights.size())
-    {
-        pScene->mLights = new aiLight*[lights.size()];
-        ::memcpy(pScene->mLights,&lights[0],lights.size()*sizeof(void*));
+    if (lights.size()) {
+        pScene->mLights = new aiLight *[lights.size()];
+        ::memcpy(pScene->mLights, &lights[0], lights.size() * sizeof(void *));
     }
 }
 

code/AC/ACLoader.h

@@ -268,7 +268,7 @@ private:
     std::vector<aiLight*>* mLights;
 
     // name counters
-    unsigned int lights, groups, polys, worlds;
+    unsigned int mLightsCounter, mGroupsCounter, mPolysCounter, mWorldsCounter;
 };
 
 } // end of namespace Assimp

code/AMF/AMFImporter_Postprocess.cpp

@@ -465,7 +465,7 @@ std::list<unsigned int> mesh_idx;
 			{
 				auto VertexIndex_GetMinimal = [](const std::list<SComplexFace>& pFaceList, const size_t* pBiggerThan) -> size_t
 				{
-					size_t rv;
+					size_t rv=0;
 
 					if(pBiggerThan != nullptr)
 					{

code/HMP/HMPLoader.cpp

@@ -118,11 +118,11 @@ void HMPImporter::InternReadFile( const std::string& pFile,
                                  aiScene* _pScene, IOSystem* _pIOHandler)
 {
     pScene     = _pScene;
-    pIOHandler = _pIOHandler;
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
+    mIOHandler = _pIOHandler;
+    std::unique_ptr<IOStream> file(mIOHandler->Open(pFile));
 
     // Check whether we can read from the file
-    if( file.get() == NULL)
+    if( file.get() == nullptr)
         throw DeadlyImportError( "Failed to open HMP file " + pFile + ".");
 
     // Check whether the HMP file is large enough to contain

code/LWO/LWOAnimation.cpp

@@ -185,9 +185,11 @@ void AnimResolver::UpdateAnimRangeSetup()
                 for (unsigned int i = 0; i < num; ++i) {
                     m = n+old_size*(i+1);
                     std::copy(n,n+old_size,m);
-
-                    if ((*it).pre == LWO::PrePostBehaviour_Oscillate && (reverse = !reverse))
+                    const bool res = ((*it).pre == LWO::PrePostBehaviour_Oscillate);
+                    reverse = !reverse;
+                    if (res && reverse ) {
                         std::reverse(m,m+old_size-1);
+                    }
                 }
 
                 // update time values
@@ -533,7 +535,7 @@ void AnimResolver::GetKeys(std::vector<aiVectorKey>& out,
 
 // ------------------------------------------------------------------------------------------------
 // Extract animation channel
-void AnimResolver::ExtractAnimChannel(aiNodeAnim** out, unsigned int flags /*= 0*/)
+void AnimResolver::ExtractAnimChannel(aiNodeAnim** out, unsigned int /*= 0*/)
 {
     *out = NULL;
 

code/MDL/MDLLoader.h

@@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -58,7 +57,6 @@ struct aiTexture;
 
 namespace Assimp    {
 
-
 using namespace MDL;
 
 // --------------------------------------------------------------------------------------
@@ -436,7 +434,7 @@ protected:
     unsigned int iGSFileVersion;
 
     /** Output I/O handler. used to load external lmp files */
-    IOSystem* pIOHandler;
+    IOSystem* mIOHandler;
 
     /** Output scene to be filled */
     aiScene* pScene;

code/Material/MaterialSystem.cpp

@@ -561,7 +561,8 @@ uint32_t Assimp::ComputeMaterialHash(const aiMaterial* mat, bool includeMatName
 
         // Exclude all properties whose first character is '?' from the hash
         // See doc for aiMaterialProperty.
-        if ((prop = mat->mProperties[i]) && (includeMatName || prop->mKey.data[0] != '?'))  {
+        prop = mat->mProperties[ i ];
+        if ( nullptr != prop && (includeMatName || prop->mKey.data[0] != '?'))  {
 
             hash = SuperFastHash(prop->mKey.data,(unsigned int)prop->mKey.length,hash);
             hash = SuperFastHash(prop->mData,prop->mDataLength,hash);

code/PostProcessing/SplitLargeMeshes.cpp

@@ -575,8 +575,9 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
                 for (unsigned int k = 0; k < pMesh->mNumBones;++k) {
                     // check whether the bone is existing
                     BoneWeightList* pcWeightList;
-                    if ((pcWeightList = (BoneWeightList*)pcMesh->mBones[k])) {
-                        aiBone* pcOldBone = pMesh->mBones[k];
+                    pcWeightList = (BoneWeightList *)pcMesh->mBones[k];
+                    if (nullptr != pcWeightList) {
+                        aiBone *pcOldBone = pMesh->mBones[k];
                         aiBone* pcOut( nullptr );
                         *ppCurrent++ = pcOut = new aiBone();
                         pcOut->mName = aiString(pcOldBone->mName);

code/PostProcessing/TextureTransform.cpp

@@ -125,7 +125,8 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
      * type (e.g. if mirroring is active there IS a difference between
      * offset 2 and 3)
      */
-    if ((rounded  = (int)info.mTranslation.x))  {
+    rounded = (int)info.mTranslation.x;
+    if (rounded) {
         float out = 0.0f;
         szTemp[0] = 0;
         if (aiTextureMapMode_Wrap == info.mapU) {
@@ -158,7 +159,8 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
      * type (e.g. if mirroring is active there IS a difference between
      * offset 2 and 3)
      */
-    if ((rounded  = (int)info.mTranslation.y))  {
+    rounded = (int)info.mTranslation.y;
+    if (rounded) {
         float out = 0.0f;
         szTemp[0] = 0;
         if (aiTextureMapMode_Wrap == info.mapV) {