Refactored StringUtils as member functions of String & the classes to be converted.

Docs/GettingStarted.dox

@@ -290,14 +290,15 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../Engine/Core ../Engine/Engine ../Engine/Graphics ../Engine/Input ../Engine/IO ../Engine/Math
-    ../Engine/Resource ../Engine/Scene ../Engine/UI
+    ../Engine/Container ../Engine/Core ../Engine/Engine ../Engine/Graphics ../Engine/Input ../Engine/IO
+    ../Engine/Math ../Engine/Resource ../Engine/Scene ../Engine/UI
 )
 
 # Define target & libraries to link
 add_executable (${TARGET_NAME} WIN32 ${SOURCE_FILES})
 set_target_properties (${TARGET_NAME} PROPERTIES DEBUG_POSTFIX _d)
-target_link_libraries (${TARGET_NAME} Core Engine Graphics Input IO Math Resource Scene UI ${DBGHELP_LIB})
+target_link_libraries (${TARGET_NAME} Container Core Engine Graphics Input IO Math Resource Scene UI 
+    ${DBGHELP_LIB})
 finalize_exe ()
 \endcode
 

Engine/Audio/Audio.cpp

@@ -177,8 +177,8 @@ bool Audio::SetMode(int bufferLengthMSec, int mixRate, bool sixteenBit, bool ste
     stereo_ = stereo;
     interpolate_ = interpolate;
     
-    LOGINFO("Set audio mode " + ToString(mixRate_) + " Hz " + (stereo_ ? "stereo" : "mono") + " " + (sixteenBit_ ? "16-bit" : "8-bit") + " " +
-        (interpolate_ ? "interpolated" : ""));
+    LOGINFO("Set audio mode " + String(mixRate_) + " Hz " + (stereo_ ? "stereo" : "mono") + " " +
+        (sixteenBit_ ? "16-bit" : "8-bit") + " " + (interpolate_ ? "interpolated" : ""));
     
     return Play();
 }

Engine/Audio/Precompiled.h

@@ -23,9 +23,8 @@
 
 #pragma once
 
-#include "StringBase.h"
-
 #include "Map.h"
 #include "PODVector.h"
 #include "Set.h"
-#include "Vector.h"
+#include "StringBase.h"
+

Engine/Container/String.cpp

@@ -24,8 +24,137 @@
 #include "StringBase.h"
 #include "Swap.h"
 
+#include <cstdio>
+
 char String::endZero = 0;
 
+String::String(int value) :
+    length_(0),
+    capacity_(0),
+    buffer_(&endZero)
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%d", value);
+    *this = tempBuffer;
+}
+
+String::String(short value) :
+    length_(0),
+    capacity_(0),
+    buffer_(&endZero)
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%d", value);
+    *this = tempBuffer;
+}
+
+String::String(unsigned value) :
+    length_(0),
+    capacity_(0),
+    buffer_(&endZero)
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%u", value);
+    *this = tempBuffer;
+}
+
+String::String(unsigned short value) :
+    length_(0),
+    capacity_(0),
+    buffer_(&endZero)
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%u", value);
+    *this = tempBuffer;
+}
+
+String::String(float value) :
+    length_(0),
+    capacity_(0),
+    buffer_(&endZero)
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%g", value);
+    *this = tempBuffer;
+}
+
+String::String(bool value) :
+    length_(0),
+    capacity_(0),
+    buffer_(&endZero)
+{
+    if (value)
+        *this = "true";
+    else
+        *this = "false";
+}
+
+String& String::operator += (int rhs)
+{
+    *this += String(rhs);
+    return *this;
+}
+
+String& String::operator += (short rhs)
+{
+    *this += String(rhs);
+    return *this;
+}
+
+String& String::operator += (unsigned rhs)
+{
+    *this += String(rhs);
+    return *this;
+}
+
+String& String::operator += (unsigned short rhs)
+{
+    *this += String(rhs);
+    return *this;
+}
+
+String& String::operator += (float rhs)
+{
+    *this += String(rhs);
+    return *this;
+}
+
+String& String::operator += (bool rhs)
+{
+    *this += String(rhs);
+    return *this;
+}
+
+String String::operator + (int rhs) const
+{
+    return *this + String(rhs);
+}
+
+String String::operator + (short rhs) const
+{
+    return *this + String(rhs);
+}
+
+String String::operator + (unsigned rhs) const
+{
+    return *this + String(rhs);
+}
+
+String String::operator + (unsigned short rhs) const
+{
+    return *this + String(rhs);
+}
+
+String String::operator + (float rhs) const
+{
+    return *this + String(rhs);
+}
+
+String String::operator + (bool rhs) const
+{
+    return *this + String(rhs);
+}
+
 void String::ReplaceInPlace(char replaceThis, char replaceWith)
 {
     for (unsigned i = 0; i < length_; ++i)
@@ -321,6 +450,46 @@ String String::ToUpper() const
     return ret;
 }
 
+Vector<String> String::Split(char separator) const
+{
+    Vector<String> ret;
+    unsigned pos = 0;
+    
+    while (pos < length_)
+    {
+        unsigned start = pos;
+        
+        while (start < length_)
+        {
+            if (buffer_[start] == separator)
+                break;
+            
+            start++;
+        }
+        
+        if (start == length_)
+        {
+            ret.Push(Substring(pos));
+            break;
+        }
+        
+        unsigned end = start;
+        
+        while (end < length_)
+        {
+            if (buffer_[end] != separator)
+                break;
+            
+            end++;
+        }
+        
+        ret.Push(Substring(pos, start - pos));
+        pos = end;
+    }
+    
+    return ret;
+}
+
 unsigned String::Find(char c, unsigned startPos) const
 {
     for (unsigned i = startPos; i < length_; ++i)

Engine/Container/StringBase.h

@@ -25,11 +25,13 @@
 
 // Note: this file is named StringBase.h to prevent conflicts with C headers
 
-#include "Iterator.h"
+#include "Vector.h"
 
 #include <cstring>
 #include <ctype.h>
 
+static const int CONVERSION_BUFFER_LENGTH = 128;
+
 /// String class
 class String
 {
@@ -63,6 +65,15 @@ public:
         *this = str;
     }
     
+    /// Construct from a C string
+    String(char* str) :
+        length_(0),
+        capacity_(0),
+        buffer_(&endZero)
+    {
+        *this = (const char*)str;
+    }
+    
     /// Construct from a char array and length
     String(const char* str, unsigned length) :
         length_(0),
@@ -73,6 +84,28 @@ public:
         CopyChars(buffer_, str, length);
     }
     
+    /// Construct from an integer
+    explicit String(int value);
+    /// Construct from a short integer
+    explicit String(short value);
+    /// Construct from an unsigned integer
+    explicit String(unsigned value);
+    /// Construct from an unsigned short integer
+    explicit String(unsigned short value);
+    /// Construct from a float
+    explicit String(float value);
+    /// Construct from a bool
+    explicit String(bool value);
+    
+    /// Construct from a convertable value
+    template <class T> explicit String(const T& value) :
+        length_(0),
+        capacity_(0),
+        buffer_(&endZero)
+    {
+        *this = value.ToString();
+    }
+    
     /// Destruct
     ~String()
     {
@@ -174,6 +207,36 @@ public:
         return ret;
     }
     
+    /// Add-assign an integer
+    String& operator += (int rhs);
+    /// Add-assign a short integer
+    String& operator += (short rhs);
+    /// Add-assign an unsigned integer
+    String& operator += (unsigned rhs);
+    /// Add-assign a short unsigned integer
+    String& operator += (unsigned short rhs);
+    /// Add-assign a float
+    String& operator += (float rhs);
+    /// Add-assign a bool
+    String& operator += (bool rhs);
+    /// Add-assign an arbitraty type
+    template <class T> String operator += (const T& rhs) { return *this += rhs.ToString(); }
+    
+    /// Add an integer
+    String operator + (int rhs) const;
+    /// Add a short integer
+    String operator + (short rhs) const;
+    /// Add an unsigned integer
+    String operator + (unsigned rhs) const;
+    /// Add a short unsigned integer
+    String operator + (unsigned short rhs) const;
+    /// Add a float
+    String operator + (float rhs) const;
+    /// Add a bool
+    String operator + (bool rhs) const;
+    /// Add an arbitrary type
+    template <class T> String operator + (const T& rhs) const { return *this + rhs.ToString(); }
+    
     /// Test for equality with another string
     bool operator == (const String& rhs) const
     {
@@ -286,6 +349,8 @@ public:
     String ToUpper() const;
     /// Return string in lowercase
     String ToLower() const;
+    /// Split string by a separator char
+    Vector<String> Split(char separator) const;
     /// Find the first occurrence of a string, or NPOS if not found
     unsigned Find(const String& str, unsigned startPos = 0) const;
     /// Find the first occurrence of a character, or NPOS if not found

Engine/Core/Precompiled.h

@@ -27,4 +27,3 @@
 #include "PODVector.h"
 #include "Set.h"
 #include "StringBase.h"
-#include "Vector.h"

Engine/Core/ProcessUtils.h

@@ -24,7 +24,6 @@
 #pragma once
 
 #include "StringBase.h"
-#include "Vector.h"
 
 class Mutex;
 

Engine/Core/StringHash.cpp

@@ -24,6 +24,8 @@
 #include "Precompiled.h"
 #include "StringUtils.h"
 
+#include <cstdio>
+
 #include "DebugNew.h"
 
 const StringHash StringHash::ZERO;
@@ -57,6 +59,13 @@ unsigned StringHash::Calculate(const char* str)
     return hash;
 }
 
+String StringHash::ToString() const
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%08X", value_);
+    return String(tempBuffer);
+}
+
 ShortStringHash::ShortStringHash(const char* str) :
     value_(Calculate(str))
 {
@@ -71,3 +80,10 @@ unsigned short ShortStringHash::Calculate(const char* str)
 {
     return StringHash::Calculate(str);
 }
+
+String ShortStringHash::ToString() const
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%04X", value_);
+    return String(tempBuffer);
+}

Engine/Core/StringHash.h

@@ -88,6 +88,8 @@ public:
     unsigned GetValue() const { return value_; }
     /// Return unsigned data
     const unsigned* GetData() const { return &value_; }
+    /// Return as string
+    String ToString() const;
     
     /// Calculate hash value case-insensitively from a C string
     static unsigned Calculate(const char* str);
@@ -169,6 +171,8 @@ public:
     unsigned short GetValue() const { return value_; }
     /// Return unsigned short data
     const unsigned short* GetData() const { return &value_; }
+    /// Return as string
+    String ToString() const;
     
     /// Calculate hash value case-insensitively from a C string
     static unsigned short Calculate(const char* str);

Engine/Core/StringUtils.cpp

@@ -29,48 +29,6 @@
 
 #include "DebugNew.h"
 
-static const int TEMP_BUFFER_LENGTH = 128;
-
-Vector<String> Split(const String& source, char separator)
-{
-    Vector<String> ret;
-    unsigned pos = 0;
-    
-    while (pos < source.Length())
-    {
-        unsigned start = pos;
-        
-        while (start < source.Length())
-        {
-            if (source[start] == separator)
-                break;
-            
-            start++;
-        }
-        
-        if (start == source.Length())
-        {
-            ret.Push(source.Substring(pos));
-            break;
-        }
-        
-        unsigned end = start;
-        
-        while (end < source.Length())
-        {
-            if (source[end] != separator)
-                break;
-            
-            end++;
-        }
-        
-        ret.Push(source.Substring(pos, start - pos));
-        pos = end;
-    }
-    
-    return ret;
-}
-
 bool ToBool(const String& source)
 {
     String temp = source.ToLower();
@@ -103,7 +61,7 @@ float ToFloat(const String& source)
 
 Color ToColor(const String& source)
 {
-    Vector<String> colors = Split(source, ' ');
+    Vector<String> colors = source.Split(' ');
     if (colors.Size() < 3)
         return Color();
     
@@ -116,7 +74,7 @@ Color ToColor(const String& source)
 
 IntRect ToIntRect(const String& source)
 {
-    Vector<String> coords = Split(source, ' ');
+    Vector<String> coords = source.Split(' ');
     if (coords.Size() < 4)
         return IntRect::ZERO;
     else
@@ -125,7 +83,7 @@ IntRect ToIntRect(const String& source)
 
 IntVector2 ToIntVector2(const String& source)
 {
-    Vector<String> coords = Split(source, ' ');
+    Vector<String> coords = source.Split(' ');
     if (coords.Size() < 2)
         return IntVector2::ZERO;
     else
@@ -134,7 +92,7 @@ IntVector2 ToIntVector2(const String& source)
 
 Rect ToRect(const String& source)
 {
-    Vector<String> coords = Split(source, ' ');
+    Vector<String> coords = source.Split(' ');
     if (coords.Size() < 4)
         return Rect::ZERO;
     else
@@ -143,7 +101,7 @@ Rect ToRect(const String& source)
 
 Quaternion ToQuaternion(const String& source)
 {
-    Vector<String> coords = Split(source, ' ');
+    Vector<String> coords = source.Split(' ');
     if (coords.Size() < 3)
         return Quaternion::IDENTITY;
     else if (coords.Size() < 4)
@@ -156,7 +114,7 @@ Quaternion ToQuaternion(const String& source)
 
 Vector2 ToVector2(const String& source)
 {
-    Vector<String> coords = Split(source, ' ');
+    Vector<String> coords = source.Split(' ');
     if (coords.Size() < 2)
         return Vector2::ZERO;
     else
@@ -165,7 +123,7 @@ Vector2 ToVector2(const String& source)
 
 Vector3 ToVector3(const String& source)
 {
-    Vector<String> coords = Split(source, ' ');
+    Vector<String> coords = source.Split(' ');
     if (coords.Size() < 3)
         return Vector3::ZERO;
     else
@@ -174,7 +132,7 @@ Vector3 ToVector3(const String& source)
 
 Vector4 ToVector4(const String& source, bool allowMissingCoords)
 {
-    Vector<String> coords = Split(source, ' ');
+    Vector<String> coords = source.Split(' ');
     if (!allowMissingCoords)
     {
         if (coords.Size() < 4)
@@ -198,105 +156,6 @@ Vector4 ToVector4(const String& source, bool allowMissingCoords)
     }
 }
 
-String ToString(bool value)
-{
-    if (value)
-        return "true";
-    else
-        return "false";
-}
-
-String ToString(float value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%g", value);
-    return String(tempBuffer);
-}
-
-String ToString(int value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%d", value);
-    return String(tempBuffer);
-}
-
-String ToString(unsigned value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%u", value);
-    return String(tempBuffer);
-}
-
-String ToString(const Color& value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%g %g %g %g", value.r_, value.g_, value.b_, value.a_);
-    return String(tempBuffer);
-}
-
-String ToString(const IntRect& value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%d %d %d &d", value.left_, value.top_, value.right_, value.bottom_);
-    return String(tempBuffer);
-}
-
-String ToString(const IntVector2& value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%d %d", value.x_, value.y_);
-    return String(tempBuffer);
-}
-
-String ToString(const Rect& value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%g %g %g %g", value.min_.x_, value.min_.y_, value.max_.x_, value.max_.y_);
-    return String(tempBuffer);
-}
-
-String ToString(const Quaternion& value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%g %g %g %g", value.w_, value.x_, value.y_, value.z_);
-    return String(tempBuffer);
-}
-
-String ToString(const StringHash& value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%08X", value.GetValue());
-    return String(tempBuffer);
-}
-
-String ToString(const ShortStringHash& value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%04X", value.GetValue());
-    return String(tempBuffer);
-}
-
-String ToString(const Vector2& value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%g %g", value.x_, value.y_);
-    return String(tempBuffer);
-}
-
-String ToString(const Vector3& value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%g %g %g", value.x_, value.y_, value.z_);
-    return String(tempBuffer);
-}
-
-String ToString(const Vector4& value)
-{
-    char tempBuffer[TEMP_BUFFER_LENGTH];
-    sprintf(tempBuffer, "%g %g %g %g", value.x_, value.y_, value.z_, value.w_);
-    return String(tempBuffer);
-}
-
 String ToString(void* value)
 {
     return ToStringHex((int)value);
@@ -304,7 +163,7 @@ String ToString(void* value)
 
 String ToStringHex(unsigned value)
 {
-    char tempBuffer[TEMP_BUFFER_LENGTH];
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
     sprintf(tempBuffer, "%08x", value);
     return String(tempBuffer);
 }

Engine/Core/StringUtils.h

@@ -27,11 +27,8 @@
 #include "Quaternion.h"
 #include "Rect.h"
 #include "StringHash.h"
-#include "Vector.h"
 #include "Vector4.h"
 
-/// Split string with a separator char
-Vector<String> Split(const String& source, char separator);
 /// Parse a bool from a string. Check for the substring "true" case-insensitively
 bool ToBool(const String& source);
 /// Parse a float from a string
@@ -56,34 +53,6 @@ Vector2 ToVector2(const String& source);
 Vector3 ToVector3(const String& source);
 /// Parse a Vector4 from a string
 Vector4 ToVector4(const String& source, bool allowMissingCoords = false);
-/// Convert a bool to string
-String ToString(bool value);
-/// Convert a float to string
-String ToString(float value);
-/// Convert an integer to string
-String ToString(int value);
-/// Convert an unsigned integer to string
-String ToString(unsigned value);
-/// Convert a Color to string
-String ToString(const Color& value);
-/// Convert an IntRect to string
-String ToString(const IntRect& value);
-/// Convert an IntVector2 to string
-String ToString(const IntVector2& value);
-/// Convert a Quaternion to string
-String ToString(const Quaternion& value);
-/// Convert a Rect to string
-String ToString(const Rect& value);
-/// Convert a StringHash to string. Return the reverse mapping if found
-String ToString(const StringHash& value);
-/// Convert a ShortStringHash to string. Return the reverse mapping if found
-String ToString(const ShortStringHash& value);
-/// Convert a Vector2 to string
-String ToString(const Vector2& value);
-/// Convert a Vector3 to string
-String ToString(const Vector3& value);
-/// Convert a Vector4 to string
-String ToString(const Vector4& value);
 /// Convert a pointer to string (returns hexadecimal)
 String ToString(void* value);
 /// Convert an unsigned integer to string as hexadecimal

Engine/Core/Variant.cpp

@@ -179,7 +179,7 @@ void Variant::FromString(const String& type, const String& value)
     {
         SetType(VAR_BUFFER);
         PODVector<unsigned char>& buffer = *(reinterpret_cast<PODVector<unsigned char>*>(value_.ptr_));
-        Vector<String> values = Split(value, ' ');
+        Vector<String> values = value.Split(' ');
         buffer.Resize(values.Size());
         for (unsigned i = 0; i < values.Size(); ++i)
             buffer[i] = ToInt(values[i]);
@@ -190,7 +190,7 @@ void Variant::FromString(const String& type, const String& value)
     }
     else if (typeLower == "objectref")
     {
-        Vector<String> values = Split(value, ';');
+        Vector<String> values = value.Split(';');
         if (values.Size() == 2)
         {
             SetType(VAR_RESOURCEREF);
@@ -201,7 +201,7 @@ void Variant::FromString(const String& type, const String& value)
     }
     else if (typeLower == "objectreflist")
     {
-        Vector<String> values = Split(value, ';');
+        Vector<String> values = value.Split(';');
         if (values.Size() >= 1)
         {
             SetType(VAR_RESOURCEREFLIST);
@@ -238,28 +238,28 @@ String Variant::ToString() const
     switch (type_)
     {
     case VAR_INT:
-        return ::ToString(value_.int_);
+        return String(value_.int_);
         
     case VAR_BOOL:
-        return ::ToString(value_.bool_);
+        return String(value_.bool_);
         
     case VAR_FLOAT:
-        return ::ToString(value_.float_);
+        return String(value_.float_);
         
     case VAR_VECTOR2:
-        return ::ToString(*(reinterpret_cast<const Vector2*>(&value_)));
+        return (reinterpret_cast<const Vector2*>(&value_))->ToString();
         
     case VAR_VECTOR3:
-        return ::ToString(*(reinterpret_cast<const Vector3*>(&value_)));
+        return (reinterpret_cast<const Vector3*>(&value_))->ToString();
         
     case VAR_VECTOR4:
-        return ::ToString(*(reinterpret_cast<const Vector4*>(&value_)));
+        return (reinterpret_cast<const Vector4*>(&value_))->ToString();
         
     case VAR_QUATERNION:
-        return ::ToString(*(reinterpret_cast<const Quaternion*>(&value_)));
+        return (reinterpret_cast<const Quaternion*>(&value_))->ToString();
         
     case VAR_COLOR:
-        return ::ToString(*(reinterpret_cast<const Color*>(&value_)));
+        return (reinterpret_cast<const Color*>(&value_))->ToString();
         
     case VAR_STRING:
         return *(reinterpret_cast<const String*>(value_.ptr_));
@@ -272,14 +272,14 @@ String Variant::ToString() const
             {
                 if (i != buffer.Begin())
                     ret += " ";
-                ret += ::ToString(*i);
+                ret += String((unsigned)*i);
             }
             return ret;
         }
         
     case VAR_PTR:
         // Pointer serialization not supported (convert to null)
-        return ::ToString((unsigned)0);
+        return String(0);
         
     case VAR_RESOURCEREF:
     case VAR_RESOURCEREFLIST:

Engine/Core/Variant.h

@@ -28,7 +28,6 @@
 #include "PODVector.h"
 #include "Quaternion.h"
 #include "StringHash.h"
-#include "Vector.h"
 #include "Vector4.h"
 
 /// Supported variable types for Variant

Engine/Engine/Console.cpp

@@ -248,7 +248,7 @@ void Console::HandleLogMessage(StringHash eventType, VariantMap& eventData)
     using namespace LogMessage;
     
     // Be prepared for possible multi-line messages
-    Vector<String> rows = Split(eventData[P_MESSAGE].GetString(), '\n');
+    Vector<String> rows = eventData[P_MESSAGE].GetString().Split('\n');
     for (unsigned i = 0; i < rows.Size(); ++i)
     {
         // Remove the first row, change its text and re-add to the bottom

Engine/Engine/CoreAPI.cpp

@@ -93,7 +93,7 @@ static void RegisterStringHash(asIScriptEngine* engine)
     engine->RegisterObjectMethod("StringHash", "bool opEquals(const StringHash&in) const", asMETHOD(StringHash, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("StringHash", "int opCmp(const StringHash&in) const", asFUNCTION(StringHashCmp), asCALL_CDECL_OBJFIRST);
     engine->RegisterObjectMethod("StringHash", "StringHash opAdd(const StringHash&in) const", asMETHOD(StringHash, operator +), asCALL_THISCALL);
-    engine->RegisterObjectMethod("StringHash", "String ToString() const", asFUNCTIONPR(ToString, (const StringHash&), String), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("StringHash", "String ToString() const", asMETHOD(StringHash, ToString), asCALL_THISCALL);
     engine->RegisterObjectMethod("StringHash", "uint get_value()", asMETHOD(StringHash, GetValue), asCALL_THISCALL);
     
     engine->RegisterObjectType("ShortStringHash", sizeof(ShortStringHash), asOBJ_VALUE | asOBJ_POD | asOBJ_APP_CLASS_CAK);
@@ -104,7 +104,7 @@ static void RegisterStringHash(asIScriptEngine* engine)
     engine->RegisterObjectMethod("ShortStringHash", "ShortStringHash &opAssign(const ShortStringHash&in)", asMETHODPR(ShortStringHash, operator =, (const ShortStringHash&), ShortStringHash&), asCALL_THISCALL);
     engine->RegisterObjectMethod("ShortStringHash", "bool opEquals(const ShortStringHash&in) const", asMETHOD(ShortStringHash, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("ShortStringHash", "int opCmp(const ShortStringHash&in) const", asFUNCTION(ShortStringHashCmp), asCALL_CDECL_OBJFIRST);
-    engine->RegisterObjectMethod("ShortStringHash", "String ToString() const", asFUNCTIONPR(ToString, (const ShortStringHash&), String), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("ShortStringHash", "String ToString() const", asMETHOD(ShortStringHash, ToString), asCALL_THISCALL);
     engine->RegisterObjectMethod("ShortStringHash", "uint16 get_value()", asMETHOD(ShortStringHash, GetValue), asCALL_THISCALL);
 }
 
@@ -436,13 +436,12 @@ static void RegisterVariant(asIScriptEngine* engine)
 
 static CScriptArray* StringSplit(char separator, const String* str)
 {
-    Vector<String> result = Split(*str, separator);
+    Vector<String> result = str->Split(separator);
     return VectorToArray<String>(result, "Array<String>");
 }
 
 static void RegisterStringUtils(asIScriptEngine* engine)
 {
-    // Register most of StringUtils as string's const methods, or objects' ToString() const methods for convenience
     engine->RegisterObjectMethod("String", "Array<String>@ Split(uint8) const", asFUNCTION(StringSplit), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "bool ToBool() const", asFUNCTION(ToBool), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "float ToFloat() const", asFUNCTION(ToFloat), asCALL_CDECL_OBJLAST);
@@ -455,10 +454,6 @@ static void RegisterStringUtils(asIScriptEngine* engine)
     engine->RegisterObjectMethod("String", "Vector2 ToVector2() const", asFUNCTION(ToVector2), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "Vector3 ToVector3() const", asFUNCTION(ToVector3), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "Vector4 ToVector4() const", asFUNCTION(ToVector4), asCALL_CDECL_OBJLAST);
-    engine->RegisterGlobalFunction("String ToString(bool)", asFUNCTIONPR(ToString, (bool), String), asCALL_CDECL);
-    engine->RegisterGlobalFunction("String ToString(float)", asFUNCTIONPR(ToString, (float), String), asCALL_CDECL);
-    engine->RegisterGlobalFunction("String ToString(int)", asFUNCTIONPR(ToString, (int), String), asCALL_CDECL);
-    engine->RegisterGlobalFunction("String ToString(uint)", asFUNCTIONPR(ToString, (unsigned), String), asCALL_CDECL);
     engine->RegisterGlobalFunction("String ToStringHex(int)", asFUNCTION(ToStringHex), asCALL_CDECL);
 }
 

Engine/Engine/DebugHud.cpp

@@ -102,12 +102,12 @@ void DebugHud::Update(float timeStep)
     if (statsText_->IsVisible())
     {
         String stats = 
-            "Triangles " + ToString(graphics->GetNumPrimitives()) +
-            "\nBatches " + ToString(graphics->GetNumBatches()) +
-            "\nViews " + ToString(renderer->GetNumViews()) + 
-            "\nLights " + ToString(renderer->GetNumLights(true)) +
-            "\nShadowmaps " + ToString(renderer->GetNumShadowMaps(true)) +
-            "\nOccluders " + ToString(renderer->GetNumOccluders(true) + renderer->GetNumShadowOccluders(true));
+            "Triangles " + String(graphics->GetNumPrimitives()) +
+            "\nBatches " + String(graphics->GetNumBatches()) +
+            "\nViews " + String(renderer->GetNumViews()) + 
+            "\nLights " + String(renderer->GetNumLights(true)) +
+            "\nShadowmaps " + String(renderer->GetNumShadowMaps(true)) +
+            "\nOccluders " + String(renderer->GetNumOccluders(true) + renderer->GetNumShadowOccluders(true));
         
         statsText_->SetText(stats);
     }
@@ -157,7 +157,7 @@ void DebugHud::Update(float timeStep)
             mode += "Off";
         
         int shadowMapSize = renderer->GetShadowMapSize();
-        mode += " Size:" + ToString(shadowMapSize);
+        mode += " Size:" + shadowMapSize;
         
         bool shadowMapHiresDepth = renderer->GetShadowMapHiresDepth();
         mode += " Depth:";

Engine/Engine/Engine.cpp

@@ -335,11 +335,11 @@ void Engine::DumpResources()
         if (num)
         {
             LOGRAW("Resource type " + i->second_.resources_.Begin()->second_->GetTypeName() +
-                ": count " + ToString(num) + " memory use " + ToString(memoryUse) + "\n");
+                ": count " + num + " memory use " + memoryUse + "\n");
         }
     }
     
-    LOGRAW("Total memory use of all resources " + ToString(cache->GetTotalMemoryUse()) + "\n\n");
+    LOGRAW("Total memory use of all resources " + String(cache->GetTotalMemoryUse()) + "\n\n");
 }
 
 void Engine::Render()

Engine/Engine/IOAPI.cpp

@@ -50,17 +50,22 @@ static void Print(const String& value)
 
 static void Print(int value)
 {
-    GetLog()->WriteRaw(ToString(value) + "\n");
+    GetLog()->WriteRaw(String(value) + "\n");
+}
+
+static void Print(unsigned value)
+{
+    GetLog()->WriteRaw(String(value) + "\n");
 }
 
 static void Print(float value)
 {
-    GetLog()->WriteRaw(ToString(value) + "\n");
+    GetLog()->WriteRaw(String(value) + "\n");
 }
 
 static void Print(bool value)
 {
-    GetLog()->WriteRaw(ToString(value) + "\n");
+    GetLog()->WriteRaw(String(value) + "\n");
 }
 
 static void LogWrite(const String& str, Log* ptr)
@@ -110,6 +115,7 @@ static void RegisterLog(asIScriptEngine* engine)
     // Register also Print() functions for convenience
     engine->RegisterGlobalFunction("void Print(const String&in)", asFUNCTIONPR(Print, (const String&), void), asCALL_CDECL);
     engine->RegisterGlobalFunction("void Print(int)", asFUNCTIONPR(Print, (int), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void Print(uint)", asFUNCTIONPR(Print, (unsigned), void), asCALL_CDECL);
     engine->RegisterGlobalFunction("void Print(float)", asFUNCTIONPR(Print, (float), void), asCALL_CDECL);
     engine->RegisterGlobalFunction("void Print(bool)", asFUNCTIONPR(Print, (bool), void), asCALL_CDECL);
 }

Engine/Engine/MathAPI.cpp

@@ -155,7 +155,7 @@ static void RegisterIntVector2(asIScriptEngine* engine)
     engine->RegisterObjectMethod("IntVector2", "IntVector2 opSub(const IntVector2&in) const", asMETHODPR(IntVector2, operator -, (const IntVector2&) const, IntVector2), asCALL_THISCALL);
     engine->RegisterObjectMethod("IntVector2", "IntVector2 opMul(int) const", asMETHODPR(IntVector2, operator *, (int) const, IntVector2), asCALL_THISCALL);
     engine->RegisterObjectMethod("IntVector2", "IntVector2 opDiv(int) const", asMETHODPR(IntVector2, operator /, (int) const, IntVector2), asCALL_THISCALL);
-    engine->RegisterObjectMethod("IntVector2", "String ToString() const", asFUNCTIONPR(ToString, (const IntVector2&), String), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("IntVector2", "String ToString() const", asMETHOD(IntVector2, ToString), asCALL_THISCALL);
     engine->RegisterObjectProperty("IntVector2", "int x", offsetof(IntVector2, x_));
     engine->RegisterObjectProperty("IntVector2", "int y", offsetof(IntVector2, y_));
 }
@@ -202,7 +202,7 @@ static void RegisterVector2(asIScriptEngine* engine)
     engine->RegisterObjectMethod("Vector2", "float AbsDotProduct(const Vector2&in) const", asMETHOD(Vector2, AbsDotProduct), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector2", "Vector2 Lerp(const Vector2&in, float) const", asMETHOD(Vector2, Lerp), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector2", "Vector2 GetNormalized() const", asMETHOD(Vector2, GetNormalized), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector2", "String ToString() const", asFUNCTIONPR(ToString, (const Vector2&), String), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Vector2", "String ToString() const", asMETHOD(Vector2, ToString), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector2", "float get_length() const", asMETHOD(Vector2, GetLength), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector2", "float get_lengthSquared() const", asMETHOD(Vector2, GetLengthSquared), asCALL_THISCALL);
     engine->RegisterObjectProperty("Vector2", "float x", offsetof(Vector2, x_));
@@ -252,7 +252,7 @@ static void RegisterVector3(asIScriptEngine* engine)
     engine->RegisterObjectMethod("Vector3", "Vector3 CrossProduct(const Vector3&in) const", asMETHOD(Vector3, CrossProduct), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector3", "Vector3 Lerp(const Vector3&in, float) const", asMETHOD(Vector3, Lerp), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector3", "Vector3 GetNormalized() const", asMETHOD(Vector3, GetNormalized), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector3", "String ToString() const", asFUNCTIONPR(ToString, (const Vector3&), String), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Vector3", "String ToString() const", asMETHOD(Vector3, ToString), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector3", "float get_length() const", asMETHOD(Vector3, GetLength), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector3", "float get_lengthSquared() const", asMETHOD(Vector3, GetLengthSquared), asCALL_THISCALL);
     engine->RegisterObjectProperty("Vector3", "float x", offsetof(Vector3, x_));
@@ -300,7 +300,7 @@ static void RegisterVector4(asIScriptEngine* engine)
     engine->RegisterObjectMethod("Vector4", "float DotProduct(const Vector4&in) const", asMETHOD(Vector4, DotProduct), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector4", "float AbsDotProduct(const Vector4&in) const", asMETHOD(Vector4, AbsDotProduct), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector4", "Vector4 Lerp(const Vector4&in, float) const", asMETHOD(Vector4, Lerp), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector4", "String ToString() const", asFUNCTIONPR(ToString, (const Vector4&), String), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Vector4", "String ToString() const", asMETHOD(Vector4, ToString), asCALL_THISCALL);
     engine->RegisterObjectProperty("Vector4", "float x", offsetof(Vector4, x_));
     engine->RegisterObjectProperty("Vector4", "float y", offsetof(Vector4, y_));
     engine->RegisterObjectProperty("Vector4", "float z", offsetof(Vector4, z_));
@@ -361,7 +361,7 @@ static void RegisterQuaternion(asIScriptEngine* engine)
     engine->RegisterObjectMethod("Quaternion", "float DotProduct(const Quaternion&in) const", asMETHOD(Quaternion, DotProduct), asCALL_THISCALL);
     engine->RegisterObjectMethod("Quaternion", "Quaternion Nlerp(const Quaternion&in, float) const", asMETHOD(Quaternion, Nlerp), asCALL_THISCALL);
     engine->RegisterObjectMethod("Quaternion", "Quaternion Slerp(const Quaternion&in, float) const", asMETHOD(Quaternion, Slerp), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Quaternion", "String ToString() const", asFUNCTIONPR(ToString, (const Quaternion&), String), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Quaternion", "String ToString() const", asMETHOD(Quaternion, ToString), asCALL_THISCALL);
     engine->RegisterObjectMethod("Quaternion", "Vector3 get_eulerAngles() const", asMETHOD(Quaternion, GetEulerAngles), asCALL_THISCALL);
     engine->RegisterObjectMethod("Quaternion", "float get_yaw() const", asMETHOD(Quaternion, GetYaw), asCALL_THISCALL);
     engine->RegisterObjectMethod("Quaternion", "float get_pitch() const", asMETHOD(Quaternion, GetPitch), asCALL_THISCALL);
@@ -604,7 +604,7 @@ static void RegisterColor(asIScriptEngine* engine)
     engine->RegisterObjectMethod("Color", "Color opMul(float) const", asMETHOD(Color, operator *), asCALL_THISCALL);
     engine->RegisterObjectMethod("Color", "Color opAdd(const Color&in) const", asMETHOD(Color, operator +), asCALL_THISCALL);
     engine->RegisterObjectMethod("Color", "Color Lerp(const Color&in, float) const", asMETHOD(Color, Lerp), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Color", "String ToString() const", asFUNCTIONPR(ToString, (const Color&), String), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Color", "String ToString() const", asMETHOD(Color, ToString), asCALL_THISCALL);
     engine->RegisterObjectMethod("Color", "Vector3 get_rgb() const", asMETHOD(Color, GetRGB), asCALL_THISCALL);
     engine->RegisterObjectMethod("Color", "float get_intensity() const", asMETHOD(Color, GetIntensity), asCALL_THISCALL);
     engine->RegisterObjectProperty("Color", "float r", offsetof(Color, r_));

Engine/Engine/Precompiled.h

@@ -26,4 +26,3 @@
 #include "Map.h"
 #include "PODVector.h"
 #include "StringBase.h"
-#include "Vector.h"

Engine/Graphics/Graphics.cpp

@@ -417,10 +417,10 @@ bool Graphics::SetMode(RenderMode mode, int width, int height, bool fullscreen,
     }
     
     if (!multiSample)
-        LOGINFO("Set screen mode " + ToString(width_) + "x" + ToString(height_) + " " + (fullscreen_ ? "fullscreen" : "windowed"));
+        LOGINFO("Set screen mode " + String(width_) + "x" + String(height_) + " " + (fullscreen_ ? "fullscreen" : "windowed"));
     else
-        LOGINFO("Set screen mode " + ToString(width_) + "x" + ToString(height_) + " " + (fullscreen_ ? "fullscreen" : "windowed") +
-        " multisample " + ToString(multiSample));
+        LOGINFO("Set screen mode " + String(width_) + "x" + String(height_) + " " + (fullscreen_ ? "fullscreen" : "windowed") +
+        " multisample " + String(multiSample));
     
     using namespace ScreenMode;
     
@@ -1761,7 +1761,7 @@ bool Graphics::BeginImmediate(PrimitiveType type, unsigned vertexCount, unsigned
     VertexBuffer* buffer = immediatevertexBuffer_[elementMask];
     if (buffer->GetVertexCount() < newSize)
     {
-        LOGDEBUG("Resized immediate vertex buffer to " + ToString(newSize));
+        LOGDEBUG("Resized immediate vertex buffer to " + newSize);
         buffer->SetSize(newSize, elementMask);
         immediateVertexBufferPos_[elementMask] = 0;
     }

Engine/Graphics/OcclusionBuffer.cpp

@@ -95,8 +95,8 @@ bool OcclusionBuffer::SetSize(int width, int height)
             break;
     }
     
-    LOGINFO("Set occlusion buffer size " + ToString(width_) + "x" + ToString(height_) + " with " + 
-        ToString(mipBuffers_.Size()) + " mip levels");
+    LOGINFO("Set occlusion buffer size " + String(width_) + "x" + String(height_) + " with " + 
+        String(mipBuffers_.Size()) + " mip levels");
     
     CalculateViewport();
     return true;

Engine/Graphics/Precompiled.h

@@ -28,4 +28,3 @@
 #include "Set.h"
 #include "Sort.h"
 #include "StringBase.h"
-#include "Vector.h"

Engine/Graphics/Renderer.cpp

@@ -1233,13 +1233,13 @@ bool Renderer::ResizeInstancingBuffer(unsigned numInstances)
     
     if (!instancingBuffer_->SetSize(newSize, INSTANCING_BUFFER_MASK, true))
     {
-        LOGERROR("Failed to resize instancing buffer to " + ToString(newSize));
+        LOGERROR("Failed to resize instancing buffer to " + newSize);
         // If failed, try to restore the old size
         instancingBuffer_->SetSize(oldSize, INSTANCING_BUFFER_MASK, true);
         return false;
     }
     
-    LOGDEBUG("Resized instancing buffer to " + ToString(newSize));
+    LOGDEBUG("Resized instancing buffer to " + newSize);
     return true;
 }
 

Engine/IO/Precompiled.h

@@ -27,4 +27,3 @@
 #include "PODVector.h"
 #include "Set.h"
 #include "StringBase.h"
-#include "Vector.h"

Engine/Math/CMakeLists.txt

@@ -6,7 +6,13 @@ file (GLOB CPP_FILES *.cpp)
 file (GLOB H_FILES *.h)
 set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
+# Include directories
+include_directories (
+    ../Container
+)
+
 # Define target & libraries to link
 add_library (${TARGET_NAME} STATIC ${SOURCE_FILES})
+target_link_libraries (${TARGET_NAME} Container)
 enable_pch ()
 finalize_lib ()

Engine/Math/Color.cpp

@@ -23,7 +23,16 @@
 
 #include "Precompiled.h"
 #include "Color.h"
+#include "StringBase.h"
+
+#include <cstdio>
 
 const Color Color::WHITE;
 const Color Color::BLACK(0.0f, 0.0f, 0.0f);
 
+String Color::ToString() const
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%g %g %g %g", r_, g_, b_, a_);
+    return String(tempBuffer);
+}

Engine/Math/Color.h

@@ -25,6 +25,8 @@
 
 #include "Vector3.h"
 
+class String;
+
 /// RGBA color
 class Color
 {
@@ -124,6 +126,9 @@ public:
         return (((a) & 0xff) << 24) | (((r) & 0xff) << 16) | (((g) & 0xff) << 8) | ((b) & 0xff);
     }
     
+    /// Return as string
+    String ToString() const;
+    
     /// Red value
     float r_;
     /// Green value

Engine/Math/Quaternion.cpp

@@ -24,6 +24,8 @@
 #include "Precompiled.h"
 #include "Quaternion.h"
 
+#include <cstdio>
+
 const Quaternion Quaternion::IDENTITY;
 
 Quaternion::Quaternion(float angle, const Vector3& axis)
@@ -230,3 +232,10 @@ Quaternion Quaternion::Slerp(Quaternion rhs, float t) const
     
     return *this * t1 + rhs * t2;
 }
+
+String Quaternion::ToString() const
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%g %g %g %g", w_, x_, y_, z_);
+    return String(tempBuffer);
+}

Engine/Math/Quaternion.h

@@ -216,6 +216,8 @@ public:
     Quaternion Slerp(Quaternion rhs, float t) const;
     /// Return float data
     const float* GetData() const { return &w_; }
+    /// Return as string
+    String ToString() const;
     
     /// W coordinate
     float w_;

Engine/Math/Rect.cpp

@@ -24,9 +24,24 @@
 #include "Precompiled.h"
 #include "Rect.h"
 
+#include <cstdio>
+
 const Rect Rect::FULL(-1.0f, -1.0f, 1.0f, 1.0f);
 const Rect Rect::POSITIVE(0.0f, 0.0f, 1.0f, 1.0f);
 const Rect Rect::ZERO(0.0f, 0.0f, 0.0f, 0.0f);
 
 const IntRect IntRect::ZERO(0, 0, 0, 0);
 
+String Rect::ToString() const
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%g %g %g %g", min_.x_, min_.y_, max_.x_, max_.y_);
+    return String(tempBuffer);
+}
+
+String IntRect::ToString() const
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%d %d %d &d", left_, top_, right_,bottom_);
+    return String(tempBuffer);
+}

Engine/Math/Rect.h

@@ -126,6 +126,8 @@ public:
     
     /// Return float data
     const void* GetData() const { return &min_.x_; }
+    /// Return as string
+    String ToString() const;
     
     /// Minimum vector
     Vector2 min_;
@@ -174,6 +176,8 @@ public:
     
     /// Return integer data
     const int* GetData() const { return &left_; }
+    /// Return as string
+    String ToString() const;
     
     /// Left coordinate
     int left_;

Engine/Math/Vector2.cpp

@@ -24,6 +24,8 @@
 #include "Precompiled.h"
 #include "Vector2.h"
 
+#include <cstdio>
+
 const Vector2 Vector2::ZERO(0.0f, 0.0f);
 const Vector2 Vector2::LEFT(-1.0f, 0.0f);
 const Vector2 Vector2::RIGHT(1.0f, 0.0f);
@@ -32,3 +34,17 @@ const Vector2 Vector2::DOWN(0.0f, -1.0f);
 const Vector2 Vector2::UNITY(1.0f, 1.0f);
 
 const IntVector2 IntVector2::ZERO(0, 0);
+
+String Vector2::ToString() const
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%g %g", x_, y_);
+    return String(tempBuffer);
+}
+
+String IntVector2::ToString() const
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%d %d", x_, y_);
+    return String(tempBuffer);
+}

Engine/Math/Vector2.h

@@ -24,6 +24,7 @@
 #pragma once
 
 #include "MathDefs.h"
+#include "StringBase.h"
 
 /// Two-dimensional vector
 class Vector2
@@ -194,6 +195,8 @@ public:
     
     /// Return float data
     const float* GetData() const { return &x_; }
+    /// Return as string
+    String ToString() const;
     
     /// X coordinate
     float x_;
@@ -293,6 +296,8 @@ public:
     
     /// Return integer data
     const int* GetData() const { return &x_; }
+    /// Return as string
+    String ToString() const;
     
     /// X coordinate
     int x_;

Engine/Math/Vector3.cpp

@@ -24,6 +24,8 @@
 #include "Precompiled.h"
 #include "Vector3.h"
 
+#include <cstdio>
+
 const Vector3 Vector3::ZERO(0.0f, 0.0f, 0.0f);
 const Vector3 Vector3::LEFT(-1.0f, 0.0f, 0.0f);
 const Vector3 Vector3::RIGHT(1.0f, 0.0f, 0.0f);
@@ -32,3 +34,10 @@ const Vector3 Vector3::DOWN(0.0f, -1.0f, 0.0f);
 const Vector3 Vector3::FORWARD(0.0f, 0.0f, 1.0f);
 const Vector3 Vector3::BACK(0.0f, 0.0f, -1.0f);
 const Vector3 Vector3::UNITY(1.0f, 1.0f, 1.0f);
+
+String Vector3::ToString() const
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%g %g %g", x_, y_, z_);
+    return String(tempBuffer);
+}

Engine/Math/Vector3.h

@@ -226,6 +226,8 @@ public:
     
     /// Return float data
     const float* GetData() const { return &x_; }
+    /// Return as string
+    String ToString() const;
     
     /// X coordinate
     float x_;

Engine/Math/Vector4.cpp

@@ -24,5 +24,14 @@
 #include "Precompiled.h"
 #include "Vector4.h"
 
+#include <cstdio>
+
 const Vector4 Vector4::ZERO(0.0f, 0.0f, 0.0f, 0.0f);
 const Vector4 Vector4::UNITY(1.0f, 1.0f, 1.0f, 1.0f);
+
+String Vector4::ToString() const
+{
+    char tempBuffer[CONVERSION_BUFFER_LENGTH];
+    sprintf(tempBuffer, "%g %g %g %g", x_, y_, z_, w_);
+    return String(tempBuffer);
+}

Engine/Math/Vector4.h

@@ -175,6 +175,8 @@ public:
     
     /// Return float data
     const float* GetData() const { return &x_; }
+    /// Return as string
+    String ToString() const;
     
     /// X coordinate
     float x_;

Engine/Network/Client.cpp

@@ -194,8 +194,8 @@ String Client::GetFileTransferStatus() const
     
     for (Map<StringHash, FileTransfer>::ConstIterator i = fileTransfers_.Begin(); i != fileTransfers_.End(); ++i)
     {
-        String line = i->second_.fileName_ + " " + ToString(i->second_.bytesReceived_) + "/" + ToString(i->second_.size_) 
-            + " (" + ToString((int)(((float)i->second_.bytesReceived_ / (float)i->second_.size_) * 100.0f + 0.5f)) + "%)\n";
+        String line = i->second_.fileName_ + " " + i->second_.bytesReceived_ + "/" + i->second_.size_
+            + " (" + String((int)(((float)i->second_.bytesReceived_ / (float)i->second_.size_) * 100.0f + 0.5f)) + "%)\n";
         ret += line;
     }
     
@@ -302,7 +302,7 @@ void Client::HandleReliablePacket(VectorBuffer& packet)
         break;
         
     default:
-        LOGERROR("Unknown message ID " + ToString((int)msgID) + " received from server");
+        LOGERROR("Unknown message ID " + String((int)msgID) + " received from server");
         break;
     }
 }
@@ -357,7 +357,7 @@ void Client::HandleTransferData(VectorBuffer& packet)
     Map<StringHash, FileTransfer>::Iterator i = fileTransfers_.Find(nameHash);
     if (i == fileTransfers_.End())
     {
-        LOGDEBUG("Received fragment for nonexisting file transfer " + ToString(nameHash));
+        LOGDEBUG("Received fragment for nonexisting file transfer " + nameHash);
         return;
     }
     FileTransfer& transfer = i->second_;
@@ -365,7 +365,7 @@ void Client::HandleTransferData(VectorBuffer& packet)
     unsigned index = packet.ReadVLE();
     if (transfer.fragmentsReceived_ != index)
     {
-        LOGERROR("Received unexpected fragment for file " + ToString(nameHash) + ", stopping transfer");
+        LOGERROR("Received unexpected fragment for file " + String(nameHash) + ", stopping transfer");
         
         using namespace FileTransferFailed;
         
@@ -387,8 +387,8 @@ void Client::HandleTransferData(VectorBuffer& packet)
     {
         if (transfer.bytesReceived_ != transfer.size_)
         {
-            LOGERROR("Transfer of file " + transfer.fileName_ + " finished, expected " + ToString(transfer.size_) +
-                " bytes but got " + ToString(transfer.bytesReceived_));
+            LOGERROR("Transfer of file " + transfer.fileName_ + " finished, expected " + transfer.size_ +
+                " bytes but got " + transfer.bytesReceived_);
             
             using namespace FileTransferFailed;
             
@@ -401,7 +401,7 @@ void Client::HandleTransferData(VectorBuffer& packet)
         {
             float totalTime = transfer.receiveTimer_.GetMSec(true) * 0.001f;
             LOGINFO("Transfer of file " + transfer.fileName_ + " completed in " +
-                ToString(totalTime) + " seconds, speed " + ToString(transfer.size_ / totalTime) + " bytes/sec");
+                totalTime + " seconds, speed " + transfer.size_ / totalTime + " bytes/sec");
             using namespace FileTransferCompleted;
             
             VariantMap eventData;
@@ -424,7 +424,7 @@ void Client::HandleTransferData(VectorBuffer& packet)
         transfer.batchStart_ = transfer.fragmentsReceived_;
         float batchTime = transfer.batchTimer_.GetMSec(true) * 0.001f;
         float newDataRate = transfer.batchSize_ * FILE_FRAGMENT_SIZE / batchTime;
-        LOGDEBUG("Received " + ToString(transfer.batchSize_) + " fragments in " + ToString(batchTime) + " seconds");
+        LOGDEBUG("Received " + String(transfer.batchSize_) + " fragments in " + String(batchTime) + " seconds");
         
         // If this was the first batch, can not yet estimate speed, so go up in batch size
         if (!transfer.lastBatchSize_)
@@ -468,11 +468,11 @@ void Client::HandleTransferFailed(VectorBuffer& packet)
     Map<StringHash, FileTransfer>::Iterator i = fileTransfers_.Find(nameHash);
     if (i == fileTransfers_.End())
     {
-        LOGDEBUG("Received fail for nonexisting file transfer " + ToString(nameHash));
+        LOGDEBUG("Received fail for nonexisting file transfer " + nameHash);
         return;
     }
     
-    String errorMsg = "Transfer of file " + ToString(nameHash) + " failed: " + reason;
+    String errorMsg = "Transfer of file " + String(nameHash) + " failed: " + reason;
     LOGINFO(errorMsg);
     
     using namespace FileTransferFailed;
@@ -537,7 +537,7 @@ void Client::HandleServerUpdate(VectorBuffer& packet, bool initial)
     {
         // If initial/full update, remove all old non-local nodes
         scene_->ClearNonLocal();
-        LOGDEBUG("Initial scene: " + ToString(packet.GetSize()) + " bytes");
+        LOGDEBUG("Initial scene: " + String(packet.GetSize()) + " bytes");
     }
     
     serverConnection_->SetFrameNumbers(lastFrameNumber, lastFrameAck);
@@ -573,7 +573,7 @@ void Client::HandleServerUpdate(VectorBuffer& packet, bool initial)
             break;
             
         default:
-            LOGWARNING("Unknown message ID " + ToString((int)msgID) + " received from server");
+            LOGWARNING("Unknown message ID " + String((int)msgID) + " received from server");
             packet.Seek(packet.GetSize()); // Break loop
             break;
         }
@@ -708,7 +708,7 @@ bool Client::RequestFile(const String& fileName, unsigned size, unsigned checksu
     serverConnection_->SendReliable(packet);
     
     fileTransfers_[nameHash] = newTransfer;
-    LOGINFO("Started transfer of file " + fileName + ", " + ToString(size) + " bytes");
+    LOGINFO("Started transfer of file " + fileName + ", " + size + " bytes");
     return true;
 }
 

Engine/Network/Connection.cpp

@@ -257,7 +257,7 @@ void Connection::ClearRemoteEvents()
 String Connection::GetIdentity() const
 {
     if (peer_)
-        return peer_->GetAddress() + ":" + ToString(peer_->GetPort());
+        return peer_->GetAddress() + ":" + peer_->GetPort();
     else
         return "Unknown";
 }

Engine/Network/Network.cpp

@@ -154,12 +154,12 @@ bool Network::StartServer(unsigned short port)
         enet_host_compress_with_range_coder(serverHost_);
     else
     {
-        LOGERROR("Failed to start server on port " + ToString(port));
+        LOGERROR("Failed to start server on port " + port);
         return false;
     }
     
 
-    LOGINFO("Started server on port " + ToString(port));
+    LOGINFO("Started server on port " + port);
     return true;
 }
 
@@ -194,7 +194,7 @@ Peer* Network::Connect(const String& address, unsigned short port)
     enetPeer->data = newPeer.GetPtr();
     peers_.Push(newPeer);
     
-    LOGINFO("Connecting to " + address + ":" + ToString(port));
+    LOGINFO("Connecting to " + address + ":" + port);
     return newPeer;
 }
 

Engine/Network/Peer.cpp

@@ -231,7 +231,7 @@ void Peer::OnConnect()
         eventData[P_PEER] = (void*)this;
         SendEvent(E_PEERCONNECTED, eventData);
         
-        LOGINFO(address_ + ":" + ToString(port_) + " connected");
+        LOGINFO(address_ + ":" + port_ + " connected");
     }
 }
 
@@ -251,7 +251,7 @@ void Peer::OnDisconnect()
         SendEvent(E_PEERDISCONNECTED, eventData);
         
         if (!address_.Empty())
-            LOGINFO(address_ + ":" + ToString(port_) + " disconnected");
+            LOGINFO(address_ + ":" + port_ + " disconnected");
         else
             LOGINFO("Disconnected");
     }

Engine/Network/Precompiled.h

@@ -27,7 +27,6 @@
 #include "PODVector.h"
 #include "Set.h"
 #include "StringBase.h"
-#include "Vector.h"
 
 #include <cstdio>
 #include <cstdlib>

Engine/Network/Server.cpp

@@ -310,7 +310,7 @@ bool Server::HandleReliablePacket(Connection* connection, VectorBuffer& packet)
         break;
         
     default:
-        Disconnect(connection, false, "Unauthorized message ID " + ToString((int)msgID) + ", disconnecting client");
+        Disconnect(connection, false, "Unauthorized message ID " + String((int)msgID) + ", disconnecting client");
         return false;
     }
     
@@ -361,7 +361,7 @@ void Server::HandleRequestFile(Connection* connection, VectorBuffer& packet)
     }
     if (!package)
     {
-        LOGWARNING("Client " + connection->GetIdentity() + " requested unknown file " + ToString(nameHash));
+        LOGWARNING("Client " + connection->GetIdentity() + " requested unknown file " + String(nameHash));
         VectorBuffer replyPacket;
         replyPacket.WriteUByte(MSG_TRANSFERFAILED);
         replyPacket.WriteStringHash(nameHash);
@@ -398,7 +398,7 @@ void Server::HandleRequestFile(Connection* connection, VectorBuffer& packet)
         return;
     
     if (!fragmentStart)
-        LOGINFO("Client " + connection->GetIdentity() + " requested file " + ToString(nameHash));
+        LOGINFO("Client " + connection->GetIdentity() + " requested file " + String(nameHash));
     
     // Send the fragments
     unsigned fragmentOffset = fragmentStart * FILE_FRAGMENT_SIZE;
@@ -532,7 +532,7 @@ bool Server::HandleClientUpdate(Connection* connection, VectorBuffer& packet)
             }
             
         default:
-            Disconnect(connection, false, "Unauthorized message ID " + ToString((int)msgID) + ", disconnecting client");
+            Disconnect(connection, false, "Unauthorized message ID " + String((int)msgID) + ", disconnecting client");
             return false;
         }
     }
@@ -589,7 +589,7 @@ void Server::SendFullUpdate(Connection* connection)
     connection->ClearRemoteEvents();
     connection->SetJoinState(JS_WAITFORACK);
     
-    LOGDEBUG("Initial scene: " + ToString(packet.GetSize()) + " bytes");
+    LOGDEBUG("Initial scene: " + String(packet.GetSize()) + " bytes");
 }
 
 void Server::SendServerUpdate(Connection* connection)

Engine/Physics/CollisionShape.cpp

@@ -845,9 +845,9 @@ void CollisionShape::CreateGeometry()
     case SHAPE_CONVEXHULL:
         {
             // Check the geometry cache
-            String id = model_->GetName() + "_" + ToString(geometryScale_) + "_" + ToString(lodLevel_);
+            String id = model_->GetName() + "_" + geometryScale_ + "_" + lodLevel_;
             if (shapeType_ == SHAPE_CONVEXHULL)
-                id += "_" + ToString(thickness_);
+                id += "_" + String(thickness_);
             
             Map<String, SharedPtr<TriangleMeshData> >& cache = physicsWorld_->GetTriangleMeshCache();
             Map<String, SharedPtr<TriangleMeshData> >::Iterator j = cache.Find(id);
@@ -870,7 +870,7 @@ void CollisionShape::CreateGeometry()
     case SHAPE_HEIGHTFIELD:
         {
             // Check the geometry cache
-            String id = model_->GetName() + "_" + ToString(numPoints_) + "_" + ToString(thickness_) + "_" + ToString(lodLevel_);
+            String id = model_->GetName() + "_" + numPoints_ + "_" + thickness_ + "_" + lodLevel_;
             
             Map<String, SharedPtr<HeightfieldData> >& cache = physicsWorld_->GetHeightfieldCache();
             Map<String, SharedPtr<HeightfieldData> >::Iterator j = cache.Find(id);

Engine/Physics/Precompiled.h

@@ -26,7 +26,6 @@
 #include "Map.h"
 #include "PODVector.h"
 #include "StringBase.h"
-#include "Vector.h"
 
 #include <cstdio>
 #include <cstdlib>

Engine/Resource/Image.cpp

@@ -374,7 +374,8 @@ CompressedLevel Image::GetCompressedLevel(unsigned index) const
         
         if (offset + level.dataSize_ > GetMemoryUse())
         {
-            LOGERROR("Compressed level is outside image data. Offset: " + ToString(offset) + " Size: " + ToString(level.dataSize_) + " Datasize: " + ToString(GetMemoryUse()));
+            LOGERROR("Compressed level is outside image data. Offset: " + String(offset) + " Size: " + String(level.dataSize_) +
+                " Datasize: " + String(GetMemoryUse()));
             level.data_ = 0;
             return level;
         }

Engine/Resource/Precompiled.h

@@ -27,4 +27,3 @@
 #include "PODVector.h"
 #include "Set.h"
 #include "StringBase.h"
-#include "Vector.h"

Engine/Resource/ResourceCache.cpp

@@ -361,7 +361,7 @@ Resource* ResourceCache::GetResource(ShortStringHash type, StringHash nameHash)
     const String& name = GetResourceName(nameHash);
     if (name.Empty())
     {
-        LOGERROR("Could not load unknown resource " + ToString(nameHash));
+        LOGERROR("Could not load unknown resource " + nameHash);
         return 0;
     }
     
@@ -369,7 +369,7 @@ Resource* ResourceCache::GetResource(ShortStringHash type, StringHash nameHash)
     resource = DynamicCast<Resource>(context_->CreateObject(type));
     if (!resource)
     {
-        LOGERROR("Could not load unknown resource type " + ToString(type));
+        LOGERROR("Could not load unknown resource type " + type);
         return 0;
     }
     

Engine/Resource/XMLElement.cpp

@@ -121,7 +121,7 @@ bool XMLElement::SetAttribute(const String& name, const String& value)
 
 bool XMLElement::SetBool(const String& name, bool value)
 {
-    return SetAttribute(name, ToString(value));
+    return SetAttribute(name, String(value));
 }
 
 bool XMLElement::SetBoundingBox(const BoundingBox& value)
@@ -137,7 +137,7 @@ bool XMLElement::SetBuffer(const String& name, const void* data, unsigned size)
     const unsigned char* bytes = (const unsigned char*)data;
     
     for (unsigned i = 0; i < size; ++i)
-        dataStr += ToString(bytes[i]) + " ";
+        dataStr += String((unsigned)bytes[i]) + " ";
     
     return SetAttribute(name, dataStr);
 }
@@ -152,37 +152,37 @@ bool XMLElement::SetBuffer(const String& name, const PODVector<unsigned char>& v
 
 bool XMLElement::SetColor(const String& name, const Color& value)
 {
-    return SetAttribute(name, ToString(value));
+    return SetAttribute(name, value.ToString());
 }
 
 bool XMLElement::SetFloat(const String& name, float value)
 {
-    return SetAttribute(name, ToString(value));
+    return SetAttribute(name, String(value));
 }
 
 bool XMLElement::SetInt(const String& name, int value)
 {
-    return SetAttribute(name, ToString(value));
+    return SetAttribute(name, String(value));
 }
 
 bool XMLElement::SetIntRect(const String& name, const IntRect& value)
 {
-    return SetAttribute(name, ToString(value));
+    return SetAttribute(name, value.ToString());
 }
 
 bool XMLElement::SetIntVector2(const String& name, const IntVector2& value)
 {
-    return SetAttribute(name, ToString(value));
+    return SetAttribute(name, value.ToString());
 }
 
 bool XMLElement::SetRect(const String& name, const Rect& value)
 {
-    return SetAttribute(name, ToString(value));
+    return SetAttribute(name, value.ToString());
 }
 
 bool XMLElement::SetQuaternion(const String& name, const Quaternion& value)
 {
-    return XMLElement::SetAttribute(name, ToString(value));
+    return XMLElement::SetAttribute(name, value.ToString());
 }
 
 bool XMLElement::SetString(const String& name, const String& value)
@@ -283,17 +283,17 @@ bool XMLElement::SetVariantMap(const VariantMap& value)
 
 bool XMLElement::SetVector2(const String& name, const Vector2& value)
 {
-    return SetAttribute(name, ToString(value));
+    return SetAttribute(name, value.ToString());
 }
 
 bool XMLElement::SetVector3(const String& name, const Vector3& value)
 {
-    return SetAttribute(name, ToString(value));
+    return SetAttribute(name, value.ToString());
 }
 
 bool XMLElement::SetVector4(const String& name, const Vector4& value)
 {
-    return SetAttribute(name, ToString(value));
+    return SetAttribute(name, value.ToString());
 }
 
 String XMLElement::GetName() const
@@ -437,7 +437,7 @@ BoundingBox XMLElement::GetBoundingBox() const
 PODVector<unsigned char> XMLElement::GetBuffer(const String& name) const
 {
     PODVector<unsigned char> ret;
-    Vector<String> bytes = Split(GetAttribute(name), ' ');
+    Vector<String> bytes = GetAttribute(name).Split(' ');
     
     ret.Resize(bytes.Size());
     for (unsigned i = 0; i < bytes.Size(); ++i)
@@ -448,7 +448,7 @@ PODVector<unsigned char> XMLElement::GetBuffer(const String& name) const
 bool XMLElement::GetBuffer(const String& name, void* dest, unsigned size) const
 {
     PODVector<unsigned char> ret;
-    Vector<String> bytes = Split(GetAttribute(name), ' ');
+    Vector<String> bytes = GetAttribute(name).Split(' ');
     unsigned char* destBytes = (unsigned char*)dest;
     if (size < bytes.Size())
         return false;
@@ -531,7 +531,7 @@ ResourceRef XMLElement::GetResourceRef() const
 {
     ResourceRef ret;
     
-    Vector<String> values = Split(GetAttribute("value"), ';');
+    Vector<String> values = GetAttribute("value").Split(';');
     if (values.Size() == 2)
     {
         ret.type_ = ShortStringHash(values[0]);
@@ -545,7 +545,7 @@ ResourceRefList XMLElement::GetResourceRefList() const
 {
     ResourceRefList ret;
     
-    Vector<String> values = Split(GetAttribute("value"), ';');
+    Vector<String> values = GetAttribute("value").Split(' ');
     if (values.Size() >= 1)
     {
         ret.type_ = ShortStringHash(values[0]);

Engine/Scene/Node.cpp

@@ -697,7 +697,7 @@ Component* Node::CreateComponent(ShortStringHash type, unsigned id, bool local)
     SharedPtr<Component> newComponent = DynamicCast<Component>(context_->CreateObject(type));
     if (!newComponent)
     {
-        LOGERROR("Could not create unknown component type " + ToString(type));
+        LOGERROR("Could not create unknown component type " + type);
         return 0;
     }
     

Engine/Scene/Precompiled.h

@@ -25,4 +25,3 @@
 
 #include "Map.h"
 #include "StringBase.h"
-#include "Vector.h"

Engine/Scene/Scene.cpp

@@ -405,7 +405,7 @@ void Scene::NodeAdded(Node* node)
     Map<unsigned, Node*>::Iterator i = allNodes_.Find(id);
     if ((i != allNodes_.End()) && (i->second_ != node))
     {
-        LOGWARNING("Overwriting node with ID " + ToString(id));
+        LOGWARNING("Overwriting node with ID " + id);
         i->second_->SetScene(0);
         i->second_->SetOwner(0);
     }

Engine/Script/Addons.cpp

@@ -624,114 +624,110 @@ void StringResize(unsigned newSize, String& str)
 
 static void ConstructStringInt(int value, String* ptr)
 {
-    new(ptr) String();
-    *ptr = ToString(value);
+    new(ptr) String(value);
 }
 
 static void ConstructStringUInt(unsigned value, String* ptr)
 {
-    new(ptr) String();
-    *ptr = ToString(value);
+    new(ptr) String(value);
 }
 
 static void ConstructStringFloat(float value, String* ptr)
 {
-    new(ptr) String();
-    *ptr = ToString(value);
+    new(ptr) String(value);
 }
 
 static void ConstructStringBool(bool value, String* ptr)
 {
-    new(ptr) String();
-    *ptr = ToString(value);
+    new(ptr) String(value);
 }
 
 static String& StringAssignInt(int value, String& str)
 {
-    str = ToString(value);
+    str = String(value);
     return str;
 }
 
 static String& StringAddAssignInt(int value, String& str)
 {
-    str += ToString(value);
+    str += String(value);
     return str;
 }
 
 static String StringAddInt(int value, const String& str)
 {
-    return str + ToString(value);
+    return str + String(value);
 }
 
 static String StringAddIntReverse(int value, const String& str)
 {
-    return ToString(value) + str;
+    return String(value) + str;
 }
 
 static String& StringAssignUInt(unsigned value, String& str)
 {
-    str = ToString(value);
+    str = String(value);
     return str;
 }
 
 static String& StringAddAssignUInt(unsigned value, String& str)
 {
-    str += ToString(value);
+    str += String(value);
     return str;
 }
 
 static String StringAddUInt(unsigned value, const String& str)
 {
-    return str + ToString(value);
+    return str + String(value);
 }
 
 static String StringAddUIntReverse(unsigned value, const String& str)
 {
-    return ToString(value) + str;
+    return String(value) + str;
 }
 
 static String& StringAssignFloat(float value, String& str)
 {
-    str = ToString(value);
+    str = String(value);
     return str;
 }
 
 static String& StringAddAssignFloat(float value, String& str)
 {
-    str += ToString(value);
+    str += String(value);
     return str;
 }
 
 static String StringAddFloat(float value, const String& str)
 {
-    return str + ToString(value);
+    return str + String(value);
 }
 
 static String StringAddFloatReverse(float value, const String& str)
 {
-    return ToString(value) + str;
+    return String(value) + str;
 }
 
 static String& StringAssignBool(bool value, String& str)
 {
-    str = ToString(value);
+    str = String(value);
     return str;
 }
 
 static String& StringAddAssignBool(bool value, String& str)
 {
-    str += ToString(value);
+    str += String(value);
     return str;
 }
 
 static String StringAddBool(bool value, const String& str)
 {
-    return str + ToString(value);
+    return str + String(value);
 }
 
 static String StringAddBoolReverse(bool value, const String& str)
 {
-    return ToString(value) + str;
+    return String(value) + str;
 }
 
 void RegisterString(asIScriptEngine *engine)

Engine/Script/Precompiled.h

@@ -26,4 +26,3 @@
 #include "Map.h"
 #include "PODVector.h"
 #include "StringBase.h"
-#include "Vector.h"

Engine/Script/Script.cpp

@@ -72,7 +72,7 @@ void ExtractPropertyInfo(const String& functionName, const String& declaration,
     {
         info->read_ = true;
         // Extract type from the return value
-        Vector<String> parts = Split(declaration, ' ');
+        Vector<String> parts = declaration.Split(' ');
         if (parts.Size())
         {
             if (parts[0] != "const")
@@ -349,7 +349,7 @@ void Script::DumpAPI()
 
 void Script::MessageCallback(const asSMessageInfo* msg)
 {
-    String message = String(msg->section) + " (" + ToString(msg->row) + "," + ToString(msg->col) + ") " +
+    String message = String(msg->section) + " (" + msg->row + "," + msg->col + ") " +
         String(msg->message);
     
     if (logMode_ == LOGMODE_IMMEDIATE)

Engine/Script/ScriptFile.cpp

@@ -128,7 +128,7 @@ void ScriptFile::AddEventHandler(Object* sender, StringHash eventType, const Str
     
     if (!sender)
     {
-        LOGERROR("Null event sender for event " + ToString(eventType) + ", handler " + handlerName);
+        LOGERROR("Null event sender for event " + String(eventType) + ", handler " + handlerName);
         return;
     }
     

Engine/Script/ScriptInstance.cpp

@@ -284,7 +284,7 @@ void ScriptInstance::AddEventHandler(Object* sender, StringHash eventType, const
 
     if (!sender)
     {
-        LOGERROR("Null event sender for event " + ToString(eventType) + ", handler " + handlerName);
+        LOGERROR("Null event sender for event " + String(eventType) + ", handler " + handlerName);
         return;
     }
     

Engine/UI/Font.cpp

@@ -143,7 +143,7 @@ const FontFace* Font::GetFace(int pointSize)
     if (error)
     {
         FT_Done_Face(face);
-        LOGERROR("Could not set font point size " + ToString(pointSize));
+        LOGERROR("Could not set font point size " + pointSize);
         return 0;
     }
     

Engine/UI/Precompiled.h

@@ -26,4 +26,3 @@
 #include "Map.h"
 #include "PODVector.h"
 #include "StringBase.h"
-#include "Vector.h"

Tools/AssetImporter/AssetImporter.cpp

@@ -154,7 +154,7 @@ aiMatrix4x4 GetDerivedTransform(aiMatrix4x4 transform, aiNode* node, aiNode* roo
 aiMatrix4x4 GetMeshBakingTransform(aiNode* meshNode, aiNode* modelRootNode);
 void GetPosRotScale(const aiMatrix4x4& transform, Vector3& pos, Quaternion& rot, Vector3& scale);
 
-String ToString(const aiString& str);
+String FromAIString(const aiString& str);
 Vector3 ToVector3(const aiVector3D& vec);
 Vector2 ToVector2(const aiVector2D& vec);
 Quaternion ToQuaternion(const aiQuaternion& quat);
@@ -409,12 +409,12 @@ void DumpNodes(aiNode* rootNode, unsigned level)
     aiMatrix4x4 transform = GetDerivedTransform(rootNode, rootNode_);
     GetPosRotScale(transform, pos, rot, scale);
     
-    PrintLine(indent + "Node " + ToString(rootNode->mName) + " pos " + ToString(pos));
+    PrintLine(indent + "Node " + FromAIString(rootNode->mName) + " pos " + String(pos));
     
     if (rootNode->mNumMeshes == 1)
-        PrintLine(indent + "  " + ToString(rootNode->mNumMeshes) + " geometry");
+        PrintLine(indent + "  " + String(rootNode->mNumMeshes) + " geometry");
     if (rootNode->mNumMeshes > 1)
-        PrintLine(indent + "  " + ToString(rootNode->mNumMeshes) + " geometries");
+        PrintLine(indent + "  " + String(rootNode->mNumMeshes) + " geometries");
     
     for (unsigned i = 0; i < rootNode->mNumChildren; ++i)
         DumpNodes(rootNode->mChildren[i], level + 1);
@@ -493,7 +493,7 @@ void CollectBones(OutModel& model)
         for (unsigned j = 0; j < mesh->mNumBones; ++j)
         {
             aiBone* bone = mesh->mBones[j];
-            String boneName(ToString(bone->mName));
+            String boneName(FromAIString(bone->mName));
             aiNode* boneNode = FindNode(boneName, scene_->mRootNode, true);
             if (!boneNode)
                 ErrorExit("Could not find scene node for bone " + boneName);
@@ -566,7 +566,7 @@ void CollectAnimations(OutModel& model)
         for (unsigned j = 0; j < anim->mNumChannels; ++j)
         {
             aiNodeAnim* channel = anim->mChannels[j];
-            String channelName = ToString(channel->mNodeName);
+            String channelName = FromAIString(channel->mNodeName);
             if (GetBoneIndex(model, channelName) != M_MAX_UNSIGNED)
             {
                 modelBoneFound = true;
@@ -588,7 +588,7 @@ void BuildBoneCollisionInfo(OutModel& model)
         for (unsigned j = 0; j < mesh->mNumBones; ++j)
         {
             aiBone* bone = mesh->mBones[j];
-            String boneName = ToString(bone->mName);
+            String boneName = FromAIString(bone->mName);
             unsigned boneIndex = GetBoneIndex(model, boneName);
             if (boneIndex == M_MAX_UNSIGNED)
                 continue;
@@ -614,7 +614,7 @@ void BuildAndSaveModel(OutModel& model)
 {
     if (!model.rootNode_)
         ErrorExit("Null root node for model");
-    String rootNodeName = ToString(model.rootNode_->mName);
+    String rootNodeName = FromAIString(model.rootNode_->mName);
     if (!model.meshes_.Size())
         ErrorExit("No geometries found starting from node " + rootNodeName);
     
@@ -668,8 +668,8 @@ void BuildAndSaveModel(OutModel& model)
             SharedPtr<Geometry> geom(new Geometry(context_));
             
             aiMesh* mesh = model.meshes_[i];
-            PrintLine("Writing geometry " + ToString(i) + " with " + ToString(mesh->mNumVertices) + " vertices " +
-                ToString(mesh->mNumFaces * 3) + " indices");
+            PrintLine("Writing geometry " + String(i) + " with " + String(mesh->mNumVertices) + " vertices " +
+                String(mesh->mNumFaces * 3) + " indices");
             
             bool largeIndices = mesh->mNumVertices > 65535;
             unsigned elementMask = GetElementMask(mesh);
@@ -749,8 +749,8 @@ void BuildAndSaveModel(OutModel& model)
             SharedPtr<Geometry> geom(new Geometry(context_));
             
             aiMesh* mesh = model.meshes_[i];
-            PrintLine("Writing geometry " + ToString(i) + " with " + ToString(mesh->mNumVertices) + " vertices " +
-                ToString(mesh->mNumFaces * 3) + " indices");
+            PrintLine("Writing geometry " + String(i) + " with " + String(mesh->mNumVertices) + " vertices " +
+                String(mesh->mNumFaces * 3) + " indices");
             
             // Build the index data
             if (!largeIndices)
@@ -797,8 +797,8 @@ void BuildAndSaveModel(OutModel& model)
     // Build skeleton if necessary
     if ((model.bones_.Size()) && (model.rootBone_))
     {
-        PrintLine("Writing skeleton with " + ToString(model.bones_.Size()) + " bones, rootbone " +
-            ToString(model.rootBone_->mName));
+        PrintLine("Writing skeleton with " + String(model.bones_.Size()) + " bones, rootbone " +
+            FromAIString(model.rootBone_->mName));
         
         Skeleton skeleton;
         Vector<Bone>& bones = skeleton.GetModifiableBones();
@@ -806,7 +806,7 @@ void BuildAndSaveModel(OutModel& model)
         for (unsigned i = 0; i < model.bones_.Size(); ++i)
         {
             aiNode* boneNode = model.bones_[i];
-            String boneName(ToString(boneNode->mName));
+            String boneName(FromAIString(boneNode->mName));
             
             Bone newBone;
             newBone.name_ = boneName;
@@ -829,7 +829,7 @@ void BuildAndSaveModel(OutModel& model)
         // Set the bone hierarchy
         for (unsigned i = 1; i < model.bones_.Size(); ++i)
         {
-            String parentName = ToString(model.bones_[i]->mParent->mName);
+            String parentName = FromAIString(model.bones_[i]->mParent->mName);
             for (unsigned j = 0; j < bones.Size(); ++j)
             {
                 if (bones[j].name_ == parentName)
@@ -856,9 +856,9 @@ void BuildAndSaveAnimations(OutModel& model)
     for (unsigned i = 0; i < model.animations_.Size(); ++i)
     {
         aiAnimation* anim = model.animations_[i];
-        String animName = ToString(anim->mName);
+        String animName = FromAIString(anim->mName);
         if (animName.Empty())
-            animName = "Anim" + ToString(i + 1);
+            animName = "Anim" + (i + 1);
         String animOutName = GetPath(model.outName_) + GetFileName(model.outName_) + "_" + SanitateAssetName(animName) + ".ani";
         
         SharedPtr<Animation> outAnim(new Animation(context_));
@@ -866,12 +866,12 @@ void BuildAndSaveAnimations(OutModel& model)
         outAnim->SetAnimationName(animName);
         outAnim->SetLength((float)anim->mDuration * tickConversion);
         
-        PrintLine("Writing animation " + animName + " length " + ToString(outAnim->GetLength()));
+        PrintLine("Writing animation " + animName + " length " + outAnim->GetLength());
         Vector<AnimationTrack> tracks;
         for (unsigned j = 0; j < anim->mNumChannels; ++j)
         {
             aiNodeAnim* channel = anim->mChannels[j];
-            String channelName = ToString(channel->mNodeName);
+            String channelName = FromAIString(channel->mNodeName);
             unsigned boneIndex = GetBoneIndex(model, channelName);
             if (boneIndex == M_MAX_UNSIGNED)
             {
@@ -1022,7 +1022,7 @@ void CollectSceneModels(OutScene& scene, aiNode* node)
     {
         OutModel model;
         model.rootNode_ = node;
-        model.outName_ = resourcePath_ + (useSubdirs_ ? "Models/" : "") + SanitateAssetName(ToString(node->mName)) + ".mdl";
+        model.outName_ = resourcePath_ + (useSubdirs_ ? "Models/" : "") + SanitateAssetName(FromAIString(node->mName)) + ".mdl";
         for (unsigned i = 0; i < meshes.Size(); ++i)
         {
             aiMesh* mesh = meshes[i].second_;
@@ -1040,7 +1040,7 @@ void CollectSceneModels(OutScene& scene, aiNode* node)
         {
             if (scene.models_[i].meshIndices_ == model.meshIndices_)
             {
-                PrintLine("Added node " + ToString(node->mName));
+                PrintLine("Added node " + FromAIString(node->mName));
                 scene.nodes_.Push(node);
                 scene.nodeModelIndices_.Push(i);
                 unique = false;
@@ -1050,7 +1050,7 @@ void CollectSceneModels(OutScene& scene, aiNode* node)
         if (unique)
         {
             PrintLine("Added model " + model.outName_);
-            PrintLine("Added node " + ToString(node->mName));
+            PrintLine("Added node " + FromAIString(node->mName));
             CollectBones(model);
             BuildBoneCollisionInfo(model);
             if (!noAnimations_)
@@ -1103,7 +1103,7 @@ void BuildAndSaveScene(OutScene& scene)
         const OutModel& model = scene.models_[scene.nodeModelIndices_[i]];
         
         // Create a static model component for each node
-        Node* modelNode = outScene->CreateChild(ToString(scene.nodes_[i]->mName));
+        Node* modelNode = outScene->CreateChild(FromAIString(scene.nodes_[i]->mName));
         StaticModel* staticModel = modelNode->CreateComponent<StaticModel>();
         
         // Create a dummy model so that the reference can be stored
@@ -1163,7 +1163,7 @@ void BuildAndSaveMaterial(aiMaterial* material, Set<String>& usedTextures)
     // Material must have name so it can be successfully saved
     aiString matNameStr;
     material->Get(AI_MATKEY_NAME, matNameStr);
-    String matName = SanitateAssetName(ToString(matNameStr));
+    String matName = SanitateAssetName(FromAIString(matNameStr));
     if (matName.Empty())
         return;
     
@@ -1187,9 +1187,9 @@ void BuildAndSaveMaterial(aiMaterial* material, Set<String>& usedTextures)
     aiColor3D colorVal;
     
     if (material->Get(AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0), stringVal) == AI_SUCCESS)
-        diffuseTexName = GetFileNameAndExtension(ToString(stringVal));
+        diffuseTexName = GetFileNameAndExtension(FromAIString(stringVal));
     if (material->Get(AI_MATKEY_TEXTURE(aiTextureType_NORMALS, 0), stringVal) == AI_SUCCESS)
-        normalTexName = GetFileNameAndExtension(ToString(stringVal));
+        normalTexName = GetFileNameAndExtension(FromAIString(stringVal));
     if (material->Get(AI_MATKEY_COLOR_DIFFUSE, colorVal) == AI_SUCCESS)
         diffuseColor = Color(colorVal.r, colorVal.g, colorVal.b);
     if (material->Get(AI_MATKEY_OPACITY, floatVal) == AI_SUCCESS)
@@ -1273,7 +1273,7 @@ void CombineLods(const Vector<float>& lodDistances, const Vector<String>& modelN
     Vector<SharedPtr<Model> > srcModels;
     for (unsigned i = 0; i < modelNames.Size(); ++i)
     {
-        PrintLine("Reading LOD level " + ToString(i) + ": model " + modelNames[i] + " distance " + ToString(lodDistances[i]));
+        PrintLine("Reading LOD level " + String(i) + ": model " + modelNames[i] + " distance " + String(lodDistances[i]));
         File srcFile(context_);
         srcFile.Open(modelNames[i]);
         SharedPtr<Model> srcModel(new Model(context_));
@@ -1359,7 +1359,7 @@ unsigned GetBoneIndex(OutModel& model, const String& boneName)
 {
     for (unsigned i = 0; i < model.bones_.Size(); ++i)
     {
-        if (ToString(model.bones_[i]->mName) == boneName)
+        if (boneName == model.bones_[i]->mName.data)
             return i;
     }
     return M_MAX_UNSIGNED;
@@ -1373,7 +1373,7 @@ aiBone* GetMeshBone(OutModel& model, const String& boneName)
         for (unsigned j = 0; j < mesh->mNumBones; ++j)
         {
             aiBone* bone = mesh->mBones[j];
-            if (ToString(bone->mName) == boneName)
+            if (boneName == bone->mName.data)
                 return bone;
         }
     }
@@ -1389,7 +1389,7 @@ Matrix4x3 GetOffsetMatrix(OutModel& model, const String& boneName)
         for (unsigned j = 0; j < mesh->mNumBones; ++j)
         {
             aiBone* bone = mesh->mBones[j];
-            if (ToString(bone->mName) == boneName)
+            if (boneName == bone->mName.data)
             {
                 aiMatrix4x4 offset = bone->mOffsetMatrix;
                 aiMatrix4x4 nodeDerivedInverse = GetMeshBakingTransform(node, model.rootNode_);
@@ -1420,7 +1420,7 @@ void GetBlendData(OutModel& model, aiMesh* mesh, Vector<unsigned>& boneMappings,
         for (unsigned i = 0; i < mesh->mNumBones; ++i)
         {
             aiBone* bone = mesh->mBones[i];
-            String boneName = ToString(bone->mName);
+            String boneName = FromAIString(bone->mName);
             unsigned globalIndex = GetBoneIndex(model, boneName);
             if (globalIndex == M_MAX_UNSIGNED)
                 ErrorExit("Bone " + boneName + " not found");
@@ -1440,7 +1440,7 @@ void GetBlendData(OutModel& model, aiMesh* mesh, Vector<unsigned>& boneMappings,
         for (unsigned i = 0; i < mesh->mNumBones; ++i)
         {
             aiBone* bone = mesh->mBones[i];
-            String boneName = ToString(bone->mName);
+            String boneName = FromAIString(bone->mName);
             unsigned globalIndex = GetBoneIndex(model, boneName);
             if (globalIndex == M_MAX_UNSIGNED)
                 ErrorExit("Bone " + boneName + " not found");
@@ -1461,7 +1461,7 @@ String GetMeshMaterialName(aiMesh* mesh)
     aiMaterial* material = scene_->mMaterials[mesh->mMaterialIndex];
     aiString matNameStr;
     material->Get(AI_MATKEY_NAME, matNameStr);
-    String matName = SanitateAssetName(ToString(matNameStr));
+    String matName = SanitateAssetName(FromAIString(matNameStr));
     if (matName.Empty())
         return matName;
     else
@@ -1579,12 +1579,12 @@ aiNode* FindNode(const String& name, aiNode* rootNode, bool caseSensitive)
         return 0;
     if (!caseSensitive)
     {
-        if (ToString(rootNode->mName).ToLower() == name.ToLower())
+        if (FromAIString(rootNode->mName).ToLower() == name.ToLower())
             return rootNode;
     }
     else
     {
-        if (ToString(rootNode->mName) == name)
+        if (name == rootNode->mName.data)
             return rootNode;
     }
     for (unsigned i = 0; i < rootNode->mNumChildren; ++i)
@@ -1633,7 +1633,7 @@ void GetPosRotScale(const aiMatrix4x4& transform, Vector3& pos, Quaternion& rot,
 }
 
 
-String ToString(const aiString& str)
+String FromAIString(const aiString& str)
 {
     return String(str.data);
 }

Tools/NormalMapTool/NormalMapTool.cpp

@@ -91,7 +91,7 @@ void Run(const Vector<String>& arguments)
         }
     }
     
-    String tempDestName = Split(arguments[0], '.')[0] + ".tga";
+    String tempDestName = arguments[0].Split('.')[0] + ".tga";
     stbi_write_tga(tempDestName.CString(), image.GetWidth(), image.GetHeight(), 4, buffer.GetPtr());
     
     String command = "texconv -f DXT5 -ft DDS -if NONE " + tempDestName;

Tools/OgreImporter/OgreImporter.cpp

@@ -487,7 +487,7 @@ void LoadMesh(const String& inputFileName, bool generateTangents, bool splitSubM
                     
                     // If still too many bones_ in one subgeometry, error
                     if (usedBoneMap.Size() > MAX_SKIN_MATRICES)
-                        ErrorExit("Too many bones_ in submesh " + ToString(subMeshIndex + 1));
+                        ErrorExit("Too many bones_ in submesh " + (subMeshIndex + 1));
                     
                     // Write mapping of vertex buffer bone indices to original bone indices
                     subGeometryLodLevel.boneMapping_.Resize(usedBoneMap.Size());
@@ -538,8 +538,8 @@ void LoadMesh(const String& inputFileName, bool generateTangents, bool splitSubM
         
         OptimizeIndices(&subGeometryLodLevel, vBuf, iBuf);
         
-        PrintLine("Processed submesh " + ToString(subMeshIndex + 1) + ": " + ToString(vertices) + " vertices " + 
-            ToString(triangles) + " triangles");
+        PrintLine("Processed submesh " + String(subMeshIndex + 1) + ": " + String(vertices) + " vertices " + 
+            String(triangles) + " triangles");
         Vector<ModelSubGeometryLodLevel> thisSubGeometry;
         thisSubGeometry.Push(subGeometryLodLevel);
         subGeometries_.Push(thisSubGeometry);
@@ -613,7 +613,7 @@ void LoadMesh(const String& inputFileName, bool generateTangents, bool splitSubM
                     OptimizeIndices(&newLodLevel, vBuf, iBuf);
                     
                     subGeometries_[subMeshIndex].Push(newLodLevel);
-                    PrintLine("Processed LOD level for submesh " + ToString(subMeshIndex + 1) + ": distance " + ToString(distance));
+                    PrintLine("Processed LOD level for submesh " + String(subMeshIndex + 1) + ": distance " + String(distance));
                     
                     lodSubMesh = lodSubMesh.GetNextElement("lodfacelist");
                 }
@@ -739,7 +739,7 @@ void LoadMesh(const String& inputFileName, bool generateTangents, bool splitSubM
                                 ++bufIndex;
                         }
                         morphs_.Push(newMorph);
-                        PrintLine("Processed morph " + name + " with " + ToString(usedPoses.Size()) + " sub-poses");
+                        PrintLine("Processed morph " + name + " with " + usedPoses.Size() + " sub-poses");
                     }
                     
                     anim = anim.GetNextElement("animation");

Tools/PackageTool/PackageTool.cpp

@@ -27,7 +27,6 @@
 #include "ProcessUtils.h"
 #include "SharedArrayPtr.h"
 #include "StringUtils.h"
-#include "Vector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -183,5 +182,5 @@ void WritePackageFile(const String& fileName, const String& rootDir)
         dest.WriteUInt(entries_[i].checksum_);
     }
     
-    PrintLine("Package total size " + ToString(dest.GetSize()) + " bytes");
+    PrintLine("Package total size " + String(dest.GetSize()) + " bytes");
 }

Tools/RampGenerator/RampGenerator.cpp

@@ -63,7 +63,7 @@ void Run(const Vector<String>& arguments)
     if ((dimensions < 1) || (dimensions > 2))
         ErrorExit("Dimensions must be 1 or 2");
     
-    String tempDestName = Split(arguments[0], '.')[0] + ".tga";
+    String tempDestName = arguments[0].Split('.')[0] + ".tga";
     
     if (dimensions == 1)
     {

Tools/ShaderCompiler/ShaderCompiler.cpp

@@ -343,7 +343,7 @@ void Run(const Vector<String>& arguments)
                     {
                         XMLElement param = parameters.CreateChildElement("parameter");
                         param.SetString("name", i->second_[j]);
-                        param.SetString("index", ToString(i->first_));
+                        param.SetInt("index", i->first_);
                     }
                 }
             }
@@ -360,7 +360,7 @@ void Run(const Vector<String>& arguments)
                     {
                         XMLElement param = parameters.CreateChildElement("parameter");
                         param.SetString("name", i->second_[j]);
-                        param.SetString("index", ToString(i->first_));
+                        param.SetInt("index", i->first_);
                     }
                 }
             }
@@ -377,7 +377,7 @@ void Run(const Vector<String>& arguments)
                     {
                         XMLElement param = parameters.CreateChildElement("parameter");
                         param.SetString("name", i->second_[j]);
-                        param.SetString("index", ToString(i->first_));
+                        param.SetInt("index", i->first_);
                     }
                 }
             }
@@ -650,7 +650,7 @@ bool Compile(ShaderType type, const String& input, const String& output, const V
     while (!dump->IsEof())
     {
         String lineStr = dump->ReadLine();
-        Vector<String> elements = Split(lineStr, ' ');
+        Vector<String> elements = lineStr.Split(' ');
         
         if (paramsStarted)
         {