Update FBXMaterial.cpp

code/AssetLib/FBX/FBXMaterial.cpp

@@ -54,7 +54,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/ByteSwapper.h>
 #include <assimp/ParsingUtils.h>
 
-#include <algorithm> // std::transform
 #include "FBXUtil.h"
 
 namespace Assimp {
@@ -81,19 +80,16 @@ Material::Material(uint64_t id, const Element& element, const Document& doc, con
         shading = "phong";
     }
 
-    std::string templateName;
-
     // lower-case shading because Blender (for example) writes "Phong"
     for (size_t i = 0; i < shading.length(); ++i) {
-        shading[i] = sttaic_cast<char>(tolower(shading[i]);
+        shading[i] = static_cast<char>(tolower(shading[i]);
     }
+    std::string templateName;
     if(shading == "phong") {
         templateName = "Material.FbxSurfacePhong";
-    }
-    else if(shading == "lambert") {
+    } else if(shading == "lambert") {
         templateName = "Material.FbxSurfaceLambert";
-    }
-    else {
+    } else {
         DOMWarning("shading mode not recognized: " + shading,&element);
     }
 
@@ -102,20 +98,19 @@ Material::Material(uint64_t id, const Element& element, const Document& doc, con
     // resolve texture links
     const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID());
     for(const Connection* con : conns) {
-
         // texture link to properties, not objects
-        if (!con->PropertyName().length()) {
+        if ( 0 == con->PropertyName().length()) {
             continue;
         }
 
         const Object* const ob = con->SourceObject();
-        if(!ob) {
+        if(nullptr == ob) {
             DOMWarning("failed to read source object for texture link, ignoring",&element);
             continue;
         }
 
         const Texture* const tex = dynamic_cast<const Texture*>(ob);
-        if(!tex) {
+        if(nullptr == tex) {
             const LayeredTexture* const layeredTexture = dynamic_cast<const LayeredTexture*>(ob);
             if(!layeredTexture) {
                 DOMWarning("source object for texture link is not a texture or layered texture, ignoring",&element);
@@ -128,9 +123,7 @@ Material::Material(uint64_t id, const Element& element, const Document& doc, con
 
             layeredTextures[prop] = layeredTexture;
             ((LayeredTexture*)layeredTexture)->fillTexture(doc);
-        }
-        else
-        {
+        } else {
             const std::string& prop = con->PropertyName();
             if (textures.find(prop) != textures.end()) {
                 DOMWarning("duplicate texture link: " + prop,&element);
@@ -138,23 +131,20 @@ Material::Material(uint64_t id, const Element& element, const Document& doc, con
 
             textures[prop] = tex;
         }
-
     }
 }
 
 
 // ------------------------------------------------------------------------------------------------
-Material::~Material()
-{
+Material::~Material() {
+    // empty
 }
 
-
 // ------------------------------------------------------------------------------------------------
-Texture::Texture(uint64_t id, const Element& element, const Document& doc, const std::string& name)
-: Object(id,element,name)
-, uvScaling(1.0f,1.0f)
-, media(0)
-{
+Texture::Texture(uint64_t id, const Element& element, const Document& doc, const std::string& name) :
+        Object(id,element,name), 
+        uvScaling(1.0f,1.0f), 
+        media(0) {
     const Scope& sc = GetRequiredScope(element);
 
     const Element* const Type = sc["Type"];
@@ -194,8 +184,7 @@ Texture::Texture(uint64_t id, const Element& element, const Document& doc, const
         crop[1] = ParseTokenAsInt(GetRequiredToken(*Cropping,1));
         crop[2] = ParseTokenAsInt(GetRequiredToken(*Cropping,2));
         crop[3] = ParseTokenAsInt(GetRequiredToken(*Cropping,3));
-    }
-    else {
+    } else {
         // vc8 doesn't support the crop() syntax in initialization lists
         // (and vc9 WARNS about the new (i.e. compliant) behaviour).
         crop[0] = crop[1] = crop[2] = crop[3] = 0;
@@ -226,7 +215,7 @@ Texture::Texture(uint64_t id, const Element& element, const Document& doc, const
         const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID());
         for(const Connection* con : conns) {
             const Object* const ob = con->SourceObject();
-            if(!ob) {
+            if (nullptr == ob) {
                 DOMWarning("failed to read source object for texture link, ignoring",&element);
                 continue;
             }
@@ -240,46 +229,38 @@ Texture::Texture(uint64_t id, const Element& element, const Document& doc, const
 }
 
 
-Texture::~Texture()
-{
-
+Texture::~Texture() {
+    // empty
 }
 
-LayeredTexture::LayeredTexture(uint64_t id, const Element& element, const Document& /*doc*/, const std::string& name)
-: Object(id,element,name)
-,blendMode(BlendMode_Modulate)
-,alpha(1)
-{
+LayeredTexture::LayeredTexture(uint64_t id, const Element& element, const Document& /*doc*/, const std::string& name) :
+        Object(id,element,name),
+        blendMode(BlendMode_Modulate),
+        alpha(1) {
     const Scope& sc = GetRequiredScope(element);
 
     const Element* const BlendModes = sc["BlendModes"];
     const Element* const Alphas = sc["Alphas"];
 
-
-    if(BlendModes!=0)
-    {
+    if (nullptr != BlendModes) {
         blendMode = (BlendMode)ParseTokenAsInt(GetRequiredToken(*BlendModes,0));
     }
-    if(Alphas!=0)
-    {
+    if (nullptr != Alphas) {
         alpha = ParseTokenAsFloat(GetRequiredToken(*Alphas,0));
     }
 }
 
-LayeredTexture::~LayeredTexture()
-{
-    
+LayeredTexture::~LayeredTexture() {
+    // empty
 }
 
-void LayeredTexture::fillTexture(const Document& doc)
-{
+void LayeredTexture::fillTexture(const Document& doc) {
     const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID());
-    for(size_t i = 0; i < conns.size();++i)
-    {
+    for(size_t i = 0; i < conns.size();++i) {
         const Connection* con = conns.at(i);
 
         const Object* const ob = con->SourceObject();
-        if(!ob) {
+        if (nullptr == ob) {
             DOMWarning("failed to read source object for texture link, ignoring",&element);
             continue;
         }
@@ -290,13 +271,11 @@ void LayeredTexture::fillTexture(const Document& doc)
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
-Video::Video(uint64_t id, const Element& element, const Document& doc, const std::string& name)
-: Object(id,element,name)
-, contentLength(0)
-, content(0)
-{
+Video::Video(uint64_t id, const Element& element, const Document& doc, const std::string& name) :
+        Object(id,element,name), 
+        contentLength(0), 
+        content(0) {
     const Scope& sc = GetRequiredScope(element);
 
     const Element* const Type = sc["Type"];
@@ -324,52 +303,43 @@ Video::Video(uint64_t id, const Element& element, const Document& doc, const std
             if (!token.IsBinary()) {
                 if (*data != '"') {
                     DOMError("embedded content is not surrounded by quotation marks", &element);
-                }
-                else {
+                } else {
                     size_t targetLength = 0;
                     auto numTokens = Content->Tokens().size();
                     // First time compute size (it could be large like 64Gb and it is good to allocate it once)
-                    for (uint32_t tokenIdx = 0; tokenIdx < numTokens; ++tokenIdx)
-                    {
+                    for (uint32_t tokenIdx = 0; tokenIdx < numTokens; ++tokenIdx) {
                         const Token& dataToken = GetRequiredToken(*Content, tokenIdx);
                         size_t tokenLength = dataToken.end() - dataToken.begin() - 2; // ignore double quotes
                         const char* base64data = dataToken.begin() + 1;
                         const size_t outLength = Util::ComputeDecodedSizeBase64(base64data, tokenLength);
-                        if (outLength == 0)
-                        {
+                        if (outLength == 0) {
                             DOMError("Corrupted embedded content found", &element);
                         }
                         targetLength += outLength;
                     }
-                    if (targetLength == 0)
-                    {
+                    if (targetLength == 0) {
                         DOMError("Corrupted embedded content found", &element);
                     }
                     content = new uint8_t[targetLength];
                     contentLength = static_cast<uint64_t>(targetLength);
                     size_t dst_offset = 0;
-                    for (uint32_t tokenIdx = 0; tokenIdx < numTokens; ++tokenIdx)
-                    {
+                    for (uint32_t tokenIdx = 0; tokenIdx < numTokens; ++tokenIdx) {
                         const Token& dataToken = GetRequiredToken(*Content, tokenIdx);
                         size_t tokenLength = dataToken.end() - dataToken.begin() - 2; // ignore double quotes
                         const char* base64data = dataToken.begin() + 1;
                         dst_offset += Util::DecodeBase64(base64data, tokenLength, content + dst_offset, targetLength - dst_offset);
                     }
-                    if (targetLength != dst_offset)
-                    {
+                    if (targetLength != dst_offset) {
                         delete[] content;
                         contentLength = 0;
                         DOMError("Corrupted embedded content found", &element);
                     }
                 }
-            }
-            else if (static_cast<size_t>(token.end() - data) < 5) {
+            } else if (static_cast<size_t>(token.end() - data) < 5) {
                 DOMError("binary data array is too short, need five (5) bytes for type signature and element count", &element);
-            }
-            else if (*data != 'R') {
+            } else if (*data != 'R') {
                 DOMWarning("video content is not raw binary data, ignoring", &element);
-            }
-            else {
+            } else {
                 // read number of elements
                 uint32_t len = 0;
                 ::memcpy(&len, data + 1, sizeof(len));
@@ -380,8 +350,7 @@ Video::Video(uint64_t id, const Element& element, const Document& doc, const std
                 content = new uint8_t[len];
                 ::memcpy(content, data + 5, len);
             }
-        } catch (const runtime_error& runtimeError)
-        {
+        } catch (const runtime_error& runtimeError) {
             //we don't need the content data for contents that has already been loaded
             ASSIMP_LOG_VERBOSE_DEBUG_F("Caught exception in FBXMaterial (likely because content was already loaded): ",
                     runtimeError.what());
@@ -392,14 +361,11 @@ Video::Video(uint64_t id, const Element& element, const Document& doc, const std
 }
 
 
-Video::~Video()
-{
-    if(content) {
-        delete[] content;
-    }
+Video::~Video() {
+    delete[] content;
 }
 
 } //!FBX
 } //!Assimp
 
-#endif
+#endif // ASSIMP_BUILD_NO_FBX_IMPORTER