Code cleanup. Reverted the more extreme XML loading optimizations for readability.

Engine/Core/StringUtils.cpp

@@ -23,8 +23,6 @@
 
 #include "Precompiled.h"
 #include "StringUtils.h"
-#include "../../ThirdParty/Assimp/code/pstdint.h"
-#include "../../ThirdParty/Assimp/code/fast_atof.h"
 
 #include <cstdio>
 #include <ctype.h>
@@ -73,14 +71,6 @@ unsigned CountElements(const String& str, char separator)
     return ret;
 }
 
-void SkipSeparator(const char** str, char separator)
-{
-    const char*& ptr = *str;
-    
-    while (ptr && *ptr && *ptr == separator)
-        ++ptr;
-}
-
 bool ToBool(const String& source)
 {
     for (unsigned i = 0; i < source.Length(); ++i)
@@ -99,21 +89,21 @@ int ToInt(const String& source)
 {
     if (!source.Length())
         return 0;
-    return Assimp::strtol10(source.CString(), 0);
+    return strtol(source.CString(), 0, 0);
 }
 
 unsigned ToUInt(const String& source)
 {
     if (!source.Length())
         return 0;
-    return Assimp::strtoul10(source.CString(), 0);
+    return strtoul(source.CString(), 0, 0);
 }
 
 float ToFloat(const String& source)
 {
     if (!source.Length())
         return 0.0f;
-    return Assimp::fast_atof(source.CString());
+    return (float)strtod(source.CString(), 0);
 }
 
 Color ToColor(const String& source)
@@ -124,19 +114,12 @@ Color ToColor(const String& source)
     if (elements < 3)
         return ret;
     
-    const char* ptr = source.CString();
-    
-    SkipSeparator(&ptr, ' ');
-    ret.r_ = Assimp::fast_atof(&ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.g_ = Assimp::fast_atof(&ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.b_ = Assimp::fast_atof(&ptr);
+    char* ptr = (char*)source.CString();
+    ret.r_ = (float)strtod(ptr, &ptr);
+    ret.g_ = (float)strtod(ptr, &ptr);
+    ret.b_ = (float)strtod(ptr, &ptr);
     if (elements > 3)
-    {
-        SkipSeparator(&ptr, ' ');
-        ret.a_ = Assimp::fast_atof(&ptr);
-    }
+        ret.a_ = (float)strtod(ptr, &ptr);
     
     return ret;
 }
@@ -149,16 +132,11 @@ IntRect ToIntRect(const String& source)
     if (elements < 4)
         return ret;
     
-    const char* ptr = source.CString();
-    
-    SkipSeparator(&ptr, ' ');
-    ret.left_ = Assimp::strtol10(ptr, &ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.top_ = Assimp::strtol10(ptr, &ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.right_ = Assimp::strtol10(ptr, &ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.bottom_ = Assimp::strtol10(ptr, &ptr);
+    char* ptr = (char*)source.CString();
+    ret.left_ = strtol(ptr, &ptr, 0);
+    ret.top_ = strtol(ptr, &ptr, 0);
+    ret.right_ = strtol(ptr, &ptr, 0);
+    ret.bottom_ = strtol(ptr, &ptr, 0);
     
     return ret;
 }
@@ -171,12 +149,9 @@ IntVector2 ToIntVector2(const String& source)
     if (elements < 2)
         return ret;
     
-    const char* ptr = source.CString();
-    
-    SkipSeparator(&ptr, ' ');
-    ret.x_ = Assimp::strtol10(ptr, &ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.y_ = Assimp::strtol10(ptr, &ptr);
+    char* ptr = (char*)source.CString();
+    ret.x_ = strtol(ptr, &ptr, 0);
+    ret.y_ = strtol(ptr, &ptr, 0);
     
     return ret;
 }
@@ -189,16 +164,11 @@ Rect ToRect(const String& source)
     if (elements < 4)
         return ret;
     
-    const char* ptr = source.CString();
-    
-    SkipSeparator(&ptr, ' ');
-    ret.min_.x_ = Assimp::fast_atof(&ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.min_.y_ = Assimp::fast_atof(&ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.max_.x_ = Assimp::fast_atof(&ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.max_.y_ = Assimp::fast_atof(&ptr);
+    char* ptr = (char*)source.CString();
+    ret.min_.x_ = (float)strtod(ptr, &ptr);
+    ret.min_.y_ = (float)strtod(ptr, &ptr);
+    ret.max_.x_ = (float)strtod(ptr, &ptr);
+    ret.max_.y_ = (float)strtod(ptr, &ptr);
     
     return ret;
 }
@@ -206,8 +176,7 @@ Rect ToRect(const String& source)
 Quaternion ToQuaternion(const String& source)
 {
     unsigned elements = CountElements(source, ' ');
-    const char* ptr = source.CString();
-    const char* end = ptr + source.Length();
+    char* ptr = (char*)source.CString();
     
     if (elements < 3)
         return Quaternion::IDENTITY;
@@ -215,12 +184,9 @@ Quaternion ToQuaternion(const String& source)
     {
         // 3 coords specified: conversion from Euler angles
         float x, y, z;
-        SkipSeparator(&ptr, ' ');
-        x = Assimp::fast_atof(&ptr);
-        SkipSeparator(&ptr, ' ');
-        y = Assimp::fast_atof(&ptr);
-        SkipSeparator(&ptr, ' ');
-        z = Assimp::fast_atof(&ptr);
+        x = (float)strtod(ptr, &ptr);
+        y = (float)strtod(ptr, &ptr);
+        z = (float)strtod(ptr, &ptr);
         
         return Quaternion(x, y, z);
     }
@@ -228,15 +194,10 @@ Quaternion ToQuaternion(const String& source)
     {
         // 4 coords specified: full quaternion
         Quaternion ret;
-        
-        SkipSeparator(&ptr, ' ');
-        ret.w_ = Assimp::fast_atof(&ptr);
-        SkipSeparator(&ptr, ' ');
-        ret.x_ = Assimp::fast_atof(&ptr);
-        SkipSeparator(&ptr, ' ');
-        ret.y_ = Assimp::fast_atof(&ptr);
-        SkipSeparator(&ptr, ' ');
-        ret.z_ = Assimp::fast_atof(&ptr);
+        ret.w_ = (float)strtod(ptr, &ptr);
+        ret.x_ = (float)strtod(ptr, &ptr);
+        ret.y_ = (float)strtod(ptr, &ptr);
+        ret.z_ = (float)strtod(ptr, &ptr);
         
         return ret;
     }
@@ -250,12 +211,9 @@ Vector2 ToVector2(const String& source)
     if (elements < 2)
         return ret;
     
-    const char* ptr = source.CString();
-    
-    SkipSeparator(&ptr, ' ');
-    ret.x_ = Assimp::fast_atof(&ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.y_ = Assimp::fast_atof(&ptr);
+    char* ptr = (char*)source.CString();
+    ret.x_ = (float)strtod(ptr, &ptr);
+    ret.y_ = (float)strtod(ptr, &ptr);
     
     return ret;
 }
@@ -268,14 +226,10 @@ Vector3 ToVector3(const String& source)
     if (elements < 3)
         return ret;
     
-    const char* ptr = source.CString();
-    
-    SkipSeparator(&ptr, ' ');
-    ret.x_ = Assimp::fast_atof(&ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.y_ = Assimp::fast_atof(&ptr);
-    SkipSeparator(&ptr, ' ');
-    ret.z_ = Assimp::fast_atof(&ptr);
+    char* ptr = (char*)source.CString();
+    ret.x_ = (float)strtod(ptr, &ptr);
+    ret.y_ = (float)strtod(ptr, &ptr);
+    ret.z_ = (float)strtod(ptr, &ptr);
     
     return ret;
 }
@@ -285,46 +239,30 @@ Vector4 ToVector4(const String& source, bool allowMissingCoords)
     Vector4 ret(Vector4::ZERO);
     
     unsigned elements = CountElements(source, ' ');
-    const char* ptr = source.CString();
+    char* ptr = (char*)source.CString();
     
     if (!allowMissingCoords)
     {
         if (elements < 4)
             return ret;
         
-        SkipSeparator(&ptr, ' ');
-        ret.x_ = Assimp::fast_atof(&ptr);
-        SkipSeparator(&ptr, ' ');
-        ret.y_ = Assimp::fast_atof(&ptr);
-        SkipSeparator(&ptr, ' ');
-        ret.z_ = Assimp::fast_atof(&ptr);
-        SkipSeparator(&ptr, ' ');
-        ret.w_ = Assimp::fast_atof(&ptr);
+        ret.x_ = (float)strtod(ptr, &ptr);
+        ret.y_ = (float)strtod(ptr, &ptr);
+        ret.z_ = (float)strtod(ptr, &ptr);
+        ret.w_ = (float)strtod(ptr, &ptr);
         
         return ret;
     }
     else
     {
         if (elements > 0)
-        {
-            SkipSeparator(&ptr, ' ');
-            ret.x_ = Assimp::fast_atof(&ptr);
-        }
+            ret.x_ = (float)strtod(ptr, &ptr);
         if (elements > 1)
-        {
-            SkipSeparator(&ptr, ' ');
-            ret.y_ = Assimp::fast_atof(&ptr);
-        }
+            ret.y_ = (float)strtod(ptr, &ptr);
         if (elements > 2)
-        {
-            SkipSeparator(&ptr, ' ');
-            ret.z_ = Assimp::fast_atof(&ptr);
-        }
+            ret.z_ = (float)strtod(ptr, &ptr);
         if (elements > 3)
-        {
-            SkipSeparator(&ptr, ' ');
-            ret.w_ = Assimp::fast_atof(&ptr);
-        }
+            ret.w_ = (float)strtod(ptr, &ptr);
         
         return ret;
     }

Engine/Resource/XMLElement.cpp

@@ -29,13 +29,6 @@
 
 #include <pugixml.hpp>
 
-static const String hashStr("hash");
-static const String maxStr("max");
-static const String minStr("min");
-static const String typeStr("type");
-static const String valueStr("value");
-static const String variantStr("variant");
-
 XMLElement::XMLElement() :
     node_(0)
 {
@@ -136,9 +129,9 @@ bool XMLElement::SetBool(const String& name, bool value)
 
 bool XMLElement::SetBoundingBox(const BoundingBox& value)
 {
-    if (!SetVector3(minStr, value.min_))
+    if (!SetVector3("min", value.min_))
         return false;
-    return SetVector3(maxStr, value.max_);
+    return SetVector3("max", value.max_);
 }
 
 bool XMLElement::SetBuffer(const String& name, const void* data, unsigned size)
@@ -202,7 +195,7 @@ bool XMLElement::SetString(const String& name, const String& value)
 
 bool XMLElement::SetVariant(const Variant& value)
 {
-    if (!SetAttribute(typeStr, value.GetTypeName()))
+    if (!SetAttribute("type", value.GetTypeName()))
         return false;
     
     return SetVariantValue(value);
@@ -225,7 +218,7 @@ bool XMLElement::SetVariantValue(const Variant& value)
         return SetVariantMap(value.GetVariantMap());
         
     default:
-        return SetAttribute(valueStr, value.ToString());
+        return SetAttribute("value", value.ToString());
     }
 }
 
@@ -238,7 +231,7 @@ bool XMLElement::SetResourceRef(const ResourceRef& value)
     Context* context = file_->GetContext();
     ResourceCache* cache = file_->GetSubsystem<ResourceCache>();
     
-    SetAttribute(valueStr, String(context->GetTypeName(value.type_)) + ";" + cache->GetResourceName(value.id_));
+    SetAttribute("value", String(context->GetTypeName(value.type_)) + ";" + cache->GetResourceName(value.id_));
     return true;
 }
 
@@ -258,19 +251,19 @@ bool XMLElement::SetResourceRefList(const ResourceRefList& value)
         str += cache->GetResourceName(value.ids_[i]);
     }
     
-    SetAttribute(valueStr, str);
+    SetAttribute("value", str);
     return true;
 }
 
 bool XMLElement::SetVariantVector(const VariantVector& value)
 {
     // Must remove all existing variant child elements (if they exist) to not cause confusion
-    if (!RemoveChildren(variantStr))
+    if (!RemoveChildren("variant"))
         return false;
     
     for (VariantVector::ConstIterator i = value.Begin(); i != value.End(); ++i)
     {
-        XMLElement variantElem = CreateChild(variantStr);
+        XMLElement variantElem = CreateChild("variant");
         if (!variantElem)
             return false;
         variantElem.SetVariant(*i);
@@ -281,15 +274,15 @@ bool XMLElement::SetVariantVector(const VariantVector& value)
 
 bool XMLElement::SetVariantMap(const VariantMap& value)
 {
-    if (!RemoveChildren(variantStr))
+    if (!RemoveChildren("variant"))
         return false;
     
     for (VariantMap::ConstIterator i = value.Begin(); i != value.End(); ++i)
     {
-        XMLElement variantElem = CreateChild(variantStr);
+        XMLElement variantElem = CreateChild("variant");
         if (!variantElem)
             return false;
-        variantElem.SetInt(hashStr, i->first_.GetValue());
+        variantElem.SetInt("hash", i->first_.GetValue());
         variantElem.SetVariant(i->second_);
     }
     
@@ -425,8 +418,8 @@ BoundingBox XMLElement::GetBoundingBox() const
 {
     BoundingBox ret;
     
-    ret.min_ = GetVector3(minStr);
-    ret.max_ = GetVector3(maxStr);
+    ret.min_ = GetVector3("min");
+    ret.max_ = GetVector3("max");
     ret.defined_ = true;
     return ret;
 }
@@ -507,7 +500,7 @@ String XMLElement::GetStringUpper(const String& name) const
 
 Variant XMLElement::GetVariant() const
 {
-    VariantType type = Variant::GetTypeFromName(GetAttribute(typeStr));
+    VariantType type = Variant::GetTypeFromName(GetAttribute("type"));
     return GetVariantValue(type);
 }
 
@@ -524,7 +517,7 @@ Variant XMLElement::GetVariantValue(VariantType type) const
     else if (type == VAR_VARIANTMAP)
         ret = GetVariantMap();
     else
-        ret.FromString(type, GetAttribute(valueStr));
+        ret.FromString(type, GetAttribute("value"));
     
     return ret;
 }
@@ -533,7 +526,7 @@ ResourceRef XMLElement::GetResourceRef() const
 {
     ResourceRef ret;
     
-    Vector<String> values = GetAttribute(valueStr).Split(';');
+    Vector<String> values = GetAttribute("value").Split(';');
     if (values.Size() == 2)
     {
         ret.type_ = ShortStringHash(values[0]);
@@ -552,7 +545,7 @@ ResourceRefList XMLElement::GetResourceRefList() const
 {
     ResourceRefList ret;
     
-    Vector<String> values = GetAttribute(valueStr).Split(';');
+    Vector<String> values = GetAttribute("value").Split(';');
     if (values.Size() >= 1)
     {
         // Whenever we encounter resource names read from a ResourceRefList XML element, store the reverse mapping to
@@ -576,11 +569,11 @@ VariantVector XMLElement::GetVariantVector() const
 {
     VariantVector ret;
     
-    XMLElement variantElem = GetChild(variantStr);
+    XMLElement variantElem = GetChild("variant");
     while (variantElem)
     {
         ret.Push(variantElem.GetVariant());
-        variantElem = variantElem.GetNext(variantStr);
+        variantElem = variantElem.GetNext("variant");
     }
     
     return ret;
@@ -590,12 +583,12 @@ VariantMap XMLElement::GetVariantMap() const
 {
     VariantMap ret;
     
-    XMLElement variantElem = GetChild(variantStr);
+    XMLElement variantElem = GetChild("variant");
     while (variantElem)
     {
-        ShortStringHash key(variantElem.GetInt(hashStr));
+        ShortStringHash key(variantElem.GetInt("hash"));
         ret[key] = variantElem.GetVariant();
-        variantElem = variantElem.GetNext(variantStr);
+        variantElem = variantElem.GetNext("variant");
     }
     
     return ret;

Engine/Scene/Node.cpp

@@ -34,9 +34,6 @@
 
 // Normalize rotation quaternion after this many incremental updates to prevent distortion
 static const int NORMALIZE_ROTATION_EVERY = 32;
-static const String componentStr("component");
-static const String idStr("id");
-static const String nodeStr("node");
 
 OBJECTTYPESTATIC(Node);
 
@@ -160,7 +157,7 @@ bool Node::LoadXML(const XMLElement& source)
     SceneResolver resolver;
     
     // Read own ID. Will not be applied, only stored for resolving possible references
-    unsigned nodeID = source.GetInt(idStr);
+    unsigned nodeID = source.GetInt("id");
     resolver.AddNode(nodeID, this);
     
     // Read attributes, components and child nodes
@@ -177,7 +174,7 @@ bool Node::LoadXML(const XMLElement& source)
 bool Node::SaveXML(XMLElement& dest)
 {
     // Write node ID
-    if (!dest.SetInt(idStr, id_))
+    if (!dest.SetInt("id", id_))
         return false;
     
     // Write attributes
@@ -188,7 +185,7 @@ bool Node::SaveXML(XMLElement& dest)
     for (unsigned i = 0; i < components_.Size(); ++i)
     {
         Component* component = components_[i];
-        XMLElement compElem = dest.CreateChild(componentStr);
+        XMLElement compElem = dest.CreateChild("component");
         if (!component->SaveXML(compElem))
             return false;
     }
@@ -197,7 +194,7 @@ bool Node::SaveXML(XMLElement& dest)
     for (unsigned i = 0; i < children_.Size(); ++i)
     {
         Node* node = children_[i];
-        XMLElement childElem = dest.CreateChild(nodeStr);
+        XMLElement childElem = dest.CreateChild("node");
         if (!node->SaveXML(childElem))
             return false;
     }
@@ -217,7 +214,7 @@ void Node::ApplyAttributes()
 bool Node::SaveXML(Serializer& dest)
 {
     SharedPtr<XMLFile> xml(new XMLFile(context_));
-    XMLElement rootElem = xml->CreateRoot(nodeStr);
+    XMLElement rootElem = xml->CreateRoot("node");
     if (!SaveXML(rootElem))
         return false;
     

Engine/Scene/Scene.cpp

@@ -39,7 +39,6 @@ static const int ASYNC_LOAD_MAX_MSEC = (int)(1000.0f / ASYNC_LOAD_MIN_FPS);
 static const float DEFAULT_SMOOTHING_CONSTANT = 50.0f;
 static const float DEFAULT_SNAP_THRESHOLD = 1.0f;
 static const String emptyVarName;
-static const String sceneStr("scene");
 
 OBJECTTYPESTATIC(Scene);
 
@@ -178,7 +177,7 @@ bool Scene::SaveXML(Serializer& dest)
     PROFILE(SaveSceneXML);
     
     SharedPtr<XMLFile> xml(new XMLFile(context_));
-    XMLElement rootElem = xml->CreateRoot(sceneStr);
+    XMLElement rootElem = xml->CreateRoot("scene");
     if (!SaveXML(rootElem))
         return false;
     

Engine/Scene/Serializable.cpp

@@ -31,10 +31,6 @@
 
 #include "DebugNew.h"
 
-static const String attributeStr("attribute");
-static const String nameStr("name");
-static const String valueStr("value");
-
 OBJECTTYPESTATIC(Serializable);
 
 Serializable::Serializable(Context* context) :
@@ -266,12 +262,12 @@ bool Serializable::LoadXML(const XMLElement& source)
     
     loading_ = true;
     
-    XMLElement attrElem = source.GetChild(attributeStr);
+    XMLElement attrElem = source.GetChild("attribute");
     unsigned startIndex = 0;
     
     while (attrElem)
     {
-        String name = attrElem.GetString(nameStr);
+        String name = attrElem.GetString("name");
         
         unsigned i = startIndex;
         unsigned attempts = attributes->Size();
@@ -284,7 +280,7 @@ bool Serializable::LoadXML(const XMLElement& source)
                 // If enums specified, do enum lookup and int assignment. Otherwise assign the variant directly
                 if (attr.enumNames_)
                 {
-                    String value = attrElem.GetString(valueStr);
+                    String value = attrElem.GetString("value");
                     const String* enumPtr = attr.enumNames_;
                     int enumValue = 0;
                     bool enumFound = false;
@@ -319,7 +315,7 @@ bool Serializable::LoadXML(const XMLElement& source)
         if (!attempts)
             LOGWARNING("Unknown attribute " + name + " in XML data");
         
-        attrElem = attrElem.GetNext(attributeStr);
+        attrElem = attrElem.GetNext("attribute");
     }
     
     loading_ = false;
@@ -346,14 +342,14 @@ bool Serializable::SaveXML(XMLElement& dest)
         if (!(attr.mode_ & AM_FILE))
             continue;
         
-        XMLElement attrElem = dest.CreateChild(attributeStr);
-        attrElem.SetString(nameStr, String(attr.name_));
+        XMLElement attrElem = dest.CreateChild("attribute");
+        attrElem.SetString("name", String(attr.name_));
         OnGetAttribute(attr, value);
         // If enums specified, set as an enum string. Otherwise set directly as a Variant
         if (attr.enumNames_)
         {
             int enumValue = value.GetInt();
-            attrElem.SetString(valueStr, String(attr.enumNames_[enumValue]));
+            attrElem.SetString("value", String(attr.enumNames_[enumValue]));
         }
         else
             attrElem.SetVariantValue(value);