Use placement new in Variant to avoid heap allocation for non-POD types.

VariantMap changed back to Map<ShortStringHash, Variant> to allow fitting inside the VariantValue structure.

Engine/Core/Variant.cpp

@@ -27,8 +27,6 @@
 
 #include <cstring>
 
-#include "DebugNew.h"
-
 const Variant Variant::EMPTY;
 const String Variant::emptyString;
 const PODVector<unsigned char> Variant::emptyBuffer;
@@ -64,27 +62,27 @@ Variant& Variant::operator = (const Variant& rhs)
     switch (type_)
     {
     case VAR_STRING:
-        *(reinterpret_cast<String*>(value_.ptr_)) = *(reinterpret_cast<const String*>(rhs.value_.ptr_));
+        *(reinterpret_cast<String*>(&value_)) = *(reinterpret_cast<const String*>(&rhs.value_));
         break;
         
     case VAR_BUFFER:
-        *(reinterpret_cast<PODVector<unsigned char>*>(value_.ptr_)) = *(reinterpret_cast<const PODVector<unsigned char>*>(rhs.value_.ptr_));
+        *(reinterpret_cast<PODVector<unsigned char>*>(&value_)) = *(reinterpret_cast<const PODVector<unsigned char>*>(&rhs.value_));
         break;
     
     case VAR_RESOURCEREF:
-        *(reinterpret_cast<ResourceRef*>(value_.ptr_)) = *(reinterpret_cast<ResourceRef*>(rhs.value_.ptr_));
+        *(reinterpret_cast<ResourceRef*>(&value_)) = *(reinterpret_cast<const ResourceRef*>(&rhs.value_));
         break;
         
     case VAR_RESOURCEREFLIST:
-        *(reinterpret_cast<ResourceRefList*>(value_.ptr_)) = *(reinterpret_cast<ResourceRefList*>(rhs.value_.ptr_));
+        *(reinterpret_cast<ResourceRefList*>(&value_)) = *(reinterpret_cast<const ResourceRefList*>(&rhs.value_));
         break;
         
     case VAR_VARIANTVECTOR:
-        *(reinterpret_cast<VariantVector*>(value_.ptr_)) = *(reinterpret_cast<VariantVector*>(rhs.value_.ptr_));
+        *(reinterpret_cast<VariantVector*>(&value_)) = *(reinterpret_cast<const VariantVector*>(&rhs.value_));
         break;
         
     case VAR_VARIANTMAP:
-        *(reinterpret_cast<VariantMap*>(value_.ptr_)) = *(reinterpret_cast<VariantMap*>(rhs.value_.ptr_));
+        *(reinterpret_cast<VariantMap*>(&value_)) = *(reinterpret_cast<const VariantMap*>(&rhs.value_));
         break;
         
     default:
@@ -130,25 +128,25 @@ bool Variant::operator == (const Variant& rhs) const
         return *(reinterpret_cast<const Color*>(&value_)) == *(reinterpret_cast<const Color*>(&rhs.value_));
         
     case VAR_STRING:
-        return *(reinterpret_cast<const String*>(value_.ptr_)) == *(reinterpret_cast<const String*>(rhs.value_.ptr_));
+        return *(reinterpret_cast<const String*>(&value_)) == *(reinterpret_cast<const String*>(&rhs.value_));
         
     case VAR_BUFFER:
-        return *(reinterpret_cast<const PODVector<unsigned char>*>(value_.ptr_)) == *(reinterpret_cast<const PODVector<unsigned char>*>(rhs.value_.ptr_));
+        return *(reinterpret_cast<const PODVector<unsigned char>*>(&value_)) == *(reinterpret_cast<const PODVector<unsigned char>*>(&rhs.value_));
         
     case VAR_PTR:
         return value_.ptr_ == rhs.value_.ptr_;
         
     case VAR_RESOURCEREF:
-        return *(reinterpret_cast<const ResourceRef*>(value_.ptr_)) == *(reinterpret_cast<const ResourceRef*>(rhs.value_.ptr_));
+        return *(reinterpret_cast<const ResourceRef*>(&value_)) == *(reinterpret_cast<const ResourceRef*>(&rhs.value_));
         
     case VAR_RESOURCEREFLIST:
-        return *(reinterpret_cast<const ResourceRefList*>(value_.ptr_)) == *(reinterpret_cast<const ResourceRefList*>(rhs.value_.ptr_));
+        return *(reinterpret_cast<const ResourceRefList*>(&value_)) == *(reinterpret_cast<const ResourceRefList*>(&rhs.value_));
         
     case VAR_VARIANTVECTOR:
-        return *(reinterpret_cast<const VariantVector*>(value_.ptr_)) == *(reinterpret_cast<const VariantVector*>(rhs.value_.ptr_));
+        return *(reinterpret_cast<const VariantVector*>(&value_)) == *(reinterpret_cast<const VariantVector*>(&rhs.value_));
         
     case VAR_VARIANTMAP:
-        return *(reinterpret_cast<const VariantMap*>(value_.ptr_)) == *(reinterpret_cast<const VariantMap*>(rhs.value_.ptr_));
+        return *(reinterpret_cast<const VariantMap*>(&value_)) == *(reinterpret_cast<const VariantMap*>(&rhs.value_));
 
     default:
         return true;
@@ -182,7 +180,7 @@ void Variant::FromString(const String& type, const String& value)
     else if (typeLower == "buffer")
     {
         SetType(VAR_BUFFER);
-        PODVector<unsigned char>& buffer = *(reinterpret_cast<PODVector<unsigned char>*>(value_.ptr_));
+        PODVector<unsigned char>& buffer = *(reinterpret_cast<PODVector<unsigned char>*>(&value_));
         Vector<String> values = value.Split(' ');
         buffer.Resize(values.Size());
         for (unsigned i = 0; i < values.Size(); ++i)
@@ -198,7 +196,7 @@ void Variant::FromString(const String& type, const String& value)
         if (values.Size() == 2)
         {
             SetType(VAR_RESOURCEREF);
-            ResourceRef& ref = *(reinterpret_cast<ResourceRef*>(value_.ptr_));
+            ResourceRef& ref = *(reinterpret_cast<ResourceRef*>(&value_));
             ref.type_ = ShortStringHash(values[0]);
             ref.id_ = StringHash(values[1]);
         }
@@ -209,7 +207,7 @@ void Variant::FromString(const String& type, const String& value)
         if (values.Size() >= 1)
         {
             SetType(VAR_RESOURCEREFLIST);
-            ResourceRefList& refList = *(reinterpret_cast<ResourceRefList*>(value_.ptr_));
+            ResourceRefList& refList = *(reinterpret_cast<ResourceRefList*>(&value_));
             refList.type_ = ShortStringHash(values[0]);
             refList.ids_.Resize(values.Size() - 1);
             for (unsigned i = 1; i < values.Size(); ++i)
@@ -226,7 +224,7 @@ void Variant::SetBuffer(const void* data, unsigned size)
         size = 0;
     
     SetType(VAR_BUFFER);
-    PODVector<unsigned char>& buffer = *(reinterpret_cast<PODVector<unsigned char>*>(value_.ptr_));
+    PODVector<unsigned char>& buffer = *(reinterpret_cast<PODVector<unsigned char>*>(&value_));
     buffer.Resize(size);
     if (size)
         memcpy(&buffer[0], data, size);
@@ -266,11 +264,11 @@ String Variant::ToString() const
         return (reinterpret_cast<const Color*>(&value_))->ToString();
         
     case VAR_STRING:
-        return *(reinterpret_cast<const String*>(value_.ptr_));
+        return *(reinterpret_cast<const String*>(&value_));
         
     case VAR_BUFFER:
         {
-            const PODVector<unsigned char>& buffer = *(reinterpret_cast<const PODVector<unsigned char>*>(value_.ptr_));
+            const PODVector<unsigned char>& buffer = *(reinterpret_cast<const PODVector<unsigned char>*>(&value_));
             String ret;
             for (PODVector<unsigned char>::ConstIterator i = buffer.Begin(); i != buffer.End(); ++i)
             {
@@ -306,27 +304,27 @@ void Variant::SetType(VariantType newType)
     switch (type_)
     {
     case VAR_STRING:
-        delete reinterpret_cast<String*>(value_.ptr_);
+        (reinterpret_cast<String*>(&value_))->~String();
         break;
         
     case VAR_BUFFER:
-        delete reinterpret_cast<PODVector<unsigned char>*>(value_.ptr_);
+        (reinterpret_cast<PODVector<unsigned char>*>(&value_))->~PODVector<unsigned char>();
         break;
         
     case VAR_RESOURCEREF:
-        delete reinterpret_cast<ResourceRef*>(value_.ptr_);
+        (reinterpret_cast<ResourceRef*>(&value_))->~ResourceRef();
         break;
         
     case VAR_RESOURCEREFLIST:
-        delete reinterpret_cast<ResourceRefList*>(value_.ptr_);
+        (reinterpret_cast<ResourceRefList*>(&value_))->~ResourceRefList();
         break;
         
     case VAR_VARIANTVECTOR:
-        delete reinterpret_cast<VariantVector*>(value_.ptr_);
+        (reinterpret_cast<VariantVector*>(&value_))->~VariantVector();
         break;
         
     case VAR_VARIANTMAP:
-        delete reinterpret_cast<VariantMap*>(value_.ptr_);
+        (reinterpret_cast<VariantMap*>(&value_))->~VariantMap();
         break;
         
     default:
@@ -338,29 +336,29 @@ void Variant::SetType(VariantType newType)
     switch (type_)
     {
     case VAR_STRING:
-        *reinterpret_cast<String**>(&value_.ptr_) = new String();
+        new(reinterpret_cast<String*>(&value_)) String();
         break;
         
     case VAR_BUFFER:
-        *reinterpret_cast<PODVector<unsigned char>**>(&value_.ptr_) = new PODVector<unsigned char>();
+        new(reinterpret_cast<PODVector<unsigned char>*>(&value_)) PODVector<unsigned char>();
         break;
         
     case VAR_RESOURCEREF:
-        *reinterpret_cast<ResourceRef**>(&value_.ptr_) = new ResourceRef();
+        new(reinterpret_cast<ResourceRef*>(&value_)) ResourceRef();
         break;
         
     case VAR_RESOURCEREFLIST:
-        *reinterpret_cast<ResourceRefList**>(&value_.ptr_) = new ResourceRefList();
+        new(reinterpret_cast<ResourceRefList*>(&value_)) ResourceRefList();
         break;
         
     case VAR_VARIANTVECTOR:
-        *reinterpret_cast<VariantVector**>(&value_.ptr_) = new VariantVector();
+        new(reinterpret_cast<VariantVector*>(&value_)) VariantVector();
         break;
         
     case VAR_VARIANTMAP:
-        *reinterpret_cast<VariantMap**>(&value_.ptr_) = new VariantMap();
+        new(reinterpret_cast<VariantMap*>(&value_)) VariantMap();
         break;
-
+        
     default:
         break;
     }

Engine/Core/Variant.h

@@ -24,7 +24,7 @@
 #pragma once
 
 #include "Color.h"
-#include "HashMap.h"
+#include "Map.h"
 #include "Quaternion.h"
 #include "StringHash.h"
 #include "Vector4.h"
@@ -50,7 +50,7 @@ enum VariantType
     VAR_VARIANTMAP
 };
 
-/// Union for holding all the possible variant values.
+/// Union for the possible variant values. Also stores non-POD objects such as String which must not exceed 16 bytes in size.
 struct VariantValue
 {
     union
@@ -141,7 +141,7 @@ class Variant;
 /// Vector of variants.
 typedef Vector<Variant> VariantVector;
 /// Map of variants.
-typedef HashMap<ShortStringHash, Variant> VariantMap;
+typedef Map<ShortStringHash, Variant> VariantMap;
 
 /// Variable that supports a fixed set of types.
 class Variant
@@ -407,7 +407,7 @@ public:
     Variant& operator = (const String& rhs)
     {
         SetType(VAR_STRING);
-        *(reinterpret_cast<String*>(value_.ptr_)) = rhs;
+        *(reinterpret_cast<String*>(&value_)) = rhs;
         return *this;
     }
     
@@ -415,7 +415,7 @@ public:
     Variant& operator = (const char* rhs)
     {
         SetType(VAR_STRING);
-        *(reinterpret_cast<String*>(value_.ptr_)) = String(rhs);
+        *(reinterpret_cast<String*>(&value_)) = String(rhs);
         return *this;
     }
 
@@ -423,7 +423,7 @@ public:
     Variant& operator = (const PODVector<unsigned char>& rhs)
     {
         SetType(VAR_BUFFER);
-        *(reinterpret_cast<PODVector<unsigned char>*>(value_.ptr_)) = rhs;
+        *(reinterpret_cast<PODVector<unsigned char>*>(&value_)) = rhs;
         return *this;
     }
     
@@ -439,7 +439,7 @@ public:
     Variant& operator = (const ResourceRef& rhs)
     {
         SetType(VAR_RESOURCEREF);
-        *(reinterpret_cast<ResourceRef*>(value_.ptr_)) = rhs;
+        *(reinterpret_cast<ResourceRef*>(&value_)) = rhs;
         return *this;
     }
     
@@ -447,7 +447,7 @@ public:
     Variant& operator = (const ResourceRefList& rhs)
     {
         SetType(VAR_RESOURCEREFLIST);
-        *(reinterpret_cast<ResourceRefList*>(value_.ptr_)) = rhs;
+        *(reinterpret_cast<ResourceRefList*>(&value_)) = rhs;
         return *this;
     }
     
@@ -455,7 +455,7 @@ public:
     Variant& operator = (const VariantVector& rhs)
     {
         SetType(VAR_VARIANTVECTOR);
-        *(reinterpret_cast<VariantVector*>(value_.ptr_)) = rhs;
+        *(reinterpret_cast<VariantVector*>(&value_)) = rhs;
         return *this;
     }
     
@@ -463,7 +463,7 @@ public:
     Variant& operator = (const VariantMap& rhs)
     {
         SetType(VAR_VARIANTMAP);
-        *(reinterpret_cast<VariantMap*>(value_.ptr_)) = rhs;
+        *(reinterpret_cast<VariantMap*>(&value_)) = rhs;
         return *this;
     }
     
@@ -557,7 +557,7 @@ public:
     bool operator == (const String& rhs) const
     {
         if (type_ == VAR_STRING)
-            return *(reinterpret_cast<const String*>(value_.ptr_)) == rhs;
+            return *(reinterpret_cast<const String*>(&value_)) == rhs;
         else
             return false;
     }
@@ -566,7 +566,7 @@ public:
     bool operator == (const PODVector<unsigned char>& rhs) const
     {
         if (type_ == VAR_BUFFER)
-            return *(reinterpret_cast<const PODVector<unsigned char>*>(value_.ptr_)) == rhs;
+            return *(reinterpret_cast<const PODVector<unsigned char>*>(&value_)) == rhs;
         else
             return false;
     }
@@ -584,7 +584,7 @@ public:
     bool operator == (const ResourceRef& rhs) const
     {
         if (type_ == VAR_RESOURCEREF)
-            return *(reinterpret_cast<ResourceRef*>(value_.ptr_)) == rhs;
+            return *(reinterpret_cast<const ResourceRef*>(&value_)) == rhs;
         else
             return false;
     }
@@ -593,7 +593,7 @@ public:
     bool operator == (const ResourceRefList& rhs) const
     {
         if (type_ == VAR_RESOURCEREFLIST)
-            return *(reinterpret_cast<ResourceRefList*>(value_.ptr_)) == rhs;
+            return *(reinterpret_cast<const ResourceRefList*>(&value_)) == rhs;
         else
             return false;
     }
@@ -602,7 +602,7 @@ public:
     bool operator == (const VariantVector& rhs) const
     {
         if (type_ == VAR_VARIANTVECTOR)
-            return *(reinterpret_cast<VariantVector*>(value_.ptr_)) == rhs;
+            return *(reinterpret_cast<const VariantVector*>(&value_)) == rhs;
         else
             return false;
     }
@@ -611,7 +611,7 @@ public:
     bool operator == (const VariantMap& rhs) const
     {
         if (type_ == VAR_VARIANTMAP)
-            return *(reinterpret_cast<VariantMap*>(value_.ptr_)) == rhs;
+            return *(reinterpret_cast<const VariantMap*>(&value_)) == rhs;
         else
             return false;
     }
@@ -767,7 +767,7 @@ public:
     {
         if (type_ != VAR_STRING)
             return emptyString;
-        return *reinterpret_cast<const String*>(value_.ptr_);
+        return *reinterpret_cast<const String*>(&value_);
     }
     
     /// Return buffer or empty on type mismatch.
@@ -775,7 +775,7 @@ public:
     {
         if (type_ != VAR_BUFFER)
             return emptyBuffer;
-        return *reinterpret_cast<const PODVector<unsigned char>*>(value_.ptr_);
+        return *reinterpret_cast<const PODVector<unsigned char>*>(&value_);
     }
     
     /// Return pointer or null on type mismatch.
@@ -791,7 +791,7 @@ public:
     {
         if (type_ != VAR_RESOURCEREF)
             return emptyResourceRef;
-        return *reinterpret_cast<ResourceRef*>(value_.ptr_);
+        return *reinterpret_cast<const ResourceRef*>(&value_);
     }
     
     /// Return a resource reference list or empty on type mismatch.
@@ -799,7 +799,7 @@ public:
     {
         if (type_ != VAR_RESOURCEREFLIST)
             return emptyResourceRefList;
-        return *reinterpret_cast<ResourceRefList*>(value_.ptr_);
+        return *reinterpret_cast<const ResourceRefList*>(&value_);
     }
     
     /// Return a variant vector or empty on type mismatch.
@@ -807,7 +807,7 @@ public:
     {
         if (type_ != VAR_VARIANTVECTOR)
             return emptyVariantVector;
-        return *reinterpret_cast<VariantVector*>(value_.ptr_);
+        return *reinterpret_cast<const VariantVector*>(&value_);
     }
     
     /// Return a variant map or empty on type mismatch
@@ -815,7 +815,7 @@ public:
     {
         if (type_ != VAR_VARIANTMAP)
             return emptyVariantMap;
-        return *reinterpret_cast<VariantMap*>(value_.ptr_);
+        return *reinterpret_cast<const VariantMap*>(&value_);
     }
 
     /// Return the value, template version.

Engine/IO/Serializer.h

@@ -23,7 +23,7 @@
 
 #pragma once
 
-#include "HashMap.h"
+#include "Map.h"
 #include "StringHash.h"
 
 class Color;
@@ -39,7 +39,7 @@ struct ResourceRef;
 struct ResourceRefList;
 
 typedef Vector<Variant> VariantVector;
-typedef HashMap<ShortStringHash, Variant> VariantMap;
+typedef Map<ShortStringHash, Variant> VariantMap;
 
 /// Abstract stream for writing.
 class Serializer

Engine/Network/Connection.h

@@ -24,6 +24,7 @@
 #pragma once
 
 #include "Controls.h"
+#include "HashMap.h"
 #include "HashSet.h"
 #include "Object.h"
 #include "ReplicationState.h"

Engine/Scene/Serializable.cpp

@@ -476,10 +476,6 @@ void Serializable::PrepareUpdates(PODVector<unsigned char>& deltaUpdateBits, Vec
     if (classCurrentState.Empty())
         classCurrentState.Resize(numAttributes);
     
-    deltaUpdateBits.Resize((numAttributes + 7) >> 3);
-    for (unsigned i = 0; i < deltaUpdateBits.Size(); ++i)
-        deltaUpdateBits[i] = 0;
-    
     for (unsigned i = 0; i < numAttributes; ++i)
     {
         const AttributeInfo& attr = attributes->At(i);
@@ -493,7 +489,15 @@ void Serializable::PrepareUpdates(PODVector<unsigned char>& deltaUpdateBits, Vec
                 latestData = true;
             else
             {
-                deltaUpdate = true;
+                if (deltaUpdate == false)
+                {
+                    // Clear the deltaupdate bits in a lazy manner when first needed
+                    deltaUpdate = true;
+                    deltaUpdateBits.Resize((numAttributes + 7) >> 3);
+                    for (unsigned i = 0; i < deltaUpdateBits.Size(); ++i)
+                        deltaUpdateBits[i] = 0;
+                }
+                
                 deltaUpdateBits[i >> 3] |= 1 << (i & 7);
             }
         }
@@ -512,8 +516,6 @@ void Serializable::WriteDeltaUpdate(Serializer& dest, PODVector<unsigned char>&
     
     for (unsigned i = 0; i < numAttributes; ++i)
     {
-        const AttributeInfo& attr = attributes->At(i);
-        
         if (deltaUpdateBits[i >> 3] & (1 << (i & 7)))
             dest.WriteVariantData(replicationState[i]);
     }
@@ -528,9 +530,7 @@ void Serializable::WriteLatestDataUpdate(Serializer& dest, Vector<Variant>& repl
     
     for (unsigned i = 0; i < numAttributes; ++i)
     {
-        const AttributeInfo& attr = attributes->At(i);
-        
-        if (attr.mode_ & AM_LATESTDATA)
+        if (attributes->At(i).mode_ & AM_LATESTDATA)
             dest.WriteVariantData(replicationState[i]);
     }
 }

Urho3D/Urho3D.cpp

@@ -89,7 +89,7 @@ void Run(const char* cmdLine)
                 break;
             }
         }
-    
+        
         // Show usage if not found
         if (scriptFileName.Empty())
         {
@@ -100,7 +100,7 @@ void Run(const char* cmdLine)
             );
             return;
         }
-    
+        
         // Create the execution context and the engine
         SharedPtr<Context> context(new Context());
         SharedPtr<Engine> engine(new Engine(context));
@@ -109,10 +109,10 @@ void Run(const char* cmdLine)
             ErrorDialog("Urho3D", context->GetSubsystem<Log>()->GetLastMessage().CString());
             return;
         }
-    
+        
         // Set 5 ms timer period to allow accurate FPS limiting up to 200 FPS
         context->GetSubsystem<Time>()->SetTimerPeriod(5);
-    
+        
         // Execute the Start function from the script file, then run the engine loop until exited
         // Hold a shared pointer to the script file to make sure it is not unloaded during runtime
         engine->InitializeScripting();