Merge pull request #160 from teamfisk/EntityFileCaching

Entity file caching

include/Engine/Core/EntityFile.h

@@ -1,164 +1,21 @@
 #ifndef EntityFile_h__
 #define EntityFile_h__
 
-#include <stack>
+#include "World.h"
-#include <boost/lexical_cast.hpp>
+#include "EntityXMLFile.h"
-#include <xercesc/util/XercesDefs.hpp>
+#include "EntityXMLFilePreprocessor.h"
-#include <xercesc/util/PlatformUtils.hpp>
+#include "EntityXMLFileParser.h"
-#include <xercesc/sax2/SAX2XMLReader.hpp>
+#include "EntityWrapper.h"
-#include <xercesc/sax2/XMLReaderFactory.hpp>
-#include <xercesc/sax2/DefaultHandler.hpp>
-#include <xercesc/sax2/Attributes.hpp>
-#include <xercesc/util/XMLString.hpp>
-#include <xercesc/util/XMLChar.hpp>
-#include <xercesc/sax2/DefaultHandler.hpp>
-#include <xercesc/framework/XMLDocumentHandler.hpp>
-#include <xercesc/framework/psvi/XSElementDeclaration.hpp>
-#include <xercesc/framework/psvi/XSComplexTypeDefinition.hpp>
-#include <xercesc/framework/psvi/XSParticle.hpp>
-#include <xercesc/framework/psvi/XSModelGroup.hpp>
-#include <xercesc/framework/psvi/XSAnnotation.hpp>
-#include <xercesc/framework/psvi/XSValue.hpp>
-#include <xercesc/framework/XMLGrammarPoolImpl.hpp>
-#include <xercesc/dom/DOM.hpp>
-#include <xercesc/dom/DOMLSInput.hpp>
-#include <xercesc/dom/DOMElement.hpp>
 
-#include "../GLM.h"
+class EntityFile : private World, public Resource
-#include "Util/XercesString.h"
-#include "ResourceManager.h"
-#include "Entity.h"
-#include "ComponentInfo.h"
-
-class EntityFileHandler
-{
-    friend class EntityFileSAXHandler;
-public:
-    // @param EntityID The entity found
-    // @param EntityID The parent of the entity
-    typedef std::function<void(EntityID, EntityID, const std::string&)> OnStartEntityCallback;
-    void SetStartEntityCallback(OnStartEntityCallback c) { m_OnStartEntityCallback = c; }
-    // @param EntityID The entity the component corresponds to
-    // @param std::string Type name of the component
-    typedef std::function<void(EntityID, const std::string&)> OnStartComponentCallback;
-    void SetStartComponentCallback(OnStartComponentCallback c) { m_OnStartComponentCallback = c; }
-    // @param EntityID Entity 
-    // @param std::string Component name 
-    // @param std::string Field name
-    // @param std::map<std::string, std::string> Field attribute names and values
-    typedef std::function<void(EntityID, const std::string&, const std::string&, const std::map<std::string, std::string>&)> OnStartFieldCallback;
-    void SetStartFieldCallback(OnStartFieldCallback c) { m_OnStartFieldCallback = c; }
-    // @param EntityID Entity 
-    // @param std::string Component name 
-    // @param std::string Field name
-    // @param char* Field data
-    typedef std::function<void(EntityID, const std::string&, const std::string&, const char*)> OnStartFieldDataCallback;
-    void SetStartFieldDataCallback(OnStartFieldDataCallback c) { m_OnStartFieldDataCallback = c; }
-
-private:
-    OnStartEntityCallback m_OnStartEntityCallback = nullptr;
-    OnStartComponentCallback m_OnStartComponentCallback = nullptr;
-    OnStartFieldCallback m_OnStartFieldCallback = nullptr;
-    OnStartFieldDataCallback m_OnStartFieldDataCallback = nullptr;
-};
-
-class EntityFileSAXHandler : public xercesc::DefaultHandler
 {
 public:
-    enum class State
+    EntityFile(std::string path);
-    {
-        Unknown,
-        Entity,
-        Component,
-        ComponentField
-    };
 
-    EntityFileSAXHandler(const EntityFileHandler* handler, xercesc::SAX2XMLReader* reader);
+    EntityWrapper MergeInto(World* other);
-
-    void startElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname, const xercesc::Attributes& attrs) override;
-    void characters(const XMLCh* const chars, const XMLSize_t length) override;
-    void endElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname) override;
-
-    void warning(const xercesc::SAXParseException& e);
-    void error(const xercesc::SAXParseException& e);
-    void fatalError(const xercesc::SAXParseException& e);
 
 private:
-    const EntityFileHandler* m_Handler;
+    EntityID m_RootEntity = EntityID_Invalid;
-    xercesc::XMLGrammarPool* m_GrammarPool;
-    xercesc::SAX2XMLReader* m_Reader;
-    //State m_CurrentScope = State::Unknown;
-    std::stack<State> m_StateStack;
-    unsigned int m_NextEntityID = 0;
-    std::stack<EntityID> m_EntityStack;
-    std::string m_CurrentComponent;
-    std::string m_CurrentField;
-    std::map<std::string, std::string> m_CurrentAttributes;
-
-    void onStartEntity(const xercesc::Attributes& attrs); 
-    void onEndEntity();
-    void onStartEntityRef(const xercesc::Attributes& attrs);
-    void onStartComponent(const std::string& name);
-    void onEndComponent(const std::string& name);
-    void onStartComponentField(const std::string& field, const xercesc::Attributes& attrs);
-    void onEndComponentField(const std::string& field);
-    void onFieldData(char* data);
-};
-
-class EntityFileXMLErrorHandler : public xercesc::ErrorHandler
-{
-public:
-	void warning(const xercesc::SAXParseException& e) override
-	{
-		reportParseException("Warning", e);
-	}
-	void error(const xercesc::SAXParseException& e) override
-	{
-		reportParseException("Error", e);
-	}
-	void fatalError(const xercesc::SAXParseException& e) override
-	{
-		reportParseException("FATAL ERROR", e);
-	}
-	void resetErrors() override { }
-
-private:
-	void reportParseException(std::string type, const xercesc::SAXParseException& e)
-	{
-		char* message = xercesc::XMLString::transcode(e.getMessage());
-		char* systemID = xercesc::XMLString::transcode(e.getSystemId());
-		std::cerr << systemID << ":" << e.getLineNumber() << ":" << e.getColumnNumber() << std::endl;
-		std::cerr << type << ": " << message << std::endl;
-		xercesc::XMLString::release(&systemID);
-		xercesc::XMLString::release(&message);
-	}
-};
-
-class EntityFile : public Resource
-{
-    friend class ResourceManager;
-    friend class EntityFileSAXHandler;
-private:
-    EntityFile(boost::filesystem::path path);
-    ~EntityFile();
-
-public:
-    static unsigned int GetTypeStride(std::string typeName);
-    static void WriteAttributeData(char* outData, const ComponentInfo::Field_t& field, const std::map<std::string, std::string>& attributes);
-    static void WriteValueData(char* outData, const ComponentInfo::Field_t& field, const char* valueData);
-
-    xercesc::XMLGrammarPool* GrammarPool() const { return m_GrammarPool; }
-
-    void Parse(const EntityFileHandler* handler) const;
-
-private:
-    boost::filesystem::path m_FilePath;
-    xercesc::XMLGrammarPool* m_GrammarPool;
-    xercesc::SAX2XMLReader* m_SAX2XMLReader;
-	//std::map<std::string, ::ComponentInfo> m_ComponentInfo;
-    //std::vector<std::string> m_EntityReferences;
-
-    static void setReaderFeatures(xercesc::SAX2XMLReader* reader);
 };
 
 #endif

include/Engine/Core/EntityXMLFile.h

@@ -0,0 +1,164 @@
+#ifndef EntityXMLFile_h__
+#define EntityXMLFile_h__
+
+#include <stack>
+#include <boost/lexical_cast.hpp>
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/util/PlatformUtils.hpp>
+#include <xercesc/sax2/SAX2XMLReader.hpp>
+#include <xercesc/sax2/XMLReaderFactory.hpp>
+#include <xercesc/sax2/DefaultHandler.hpp>
+#include <xercesc/sax2/Attributes.hpp>
+#include <xercesc/util/XMLString.hpp>
+#include <xercesc/util/XMLChar.hpp>
+#include <xercesc/sax2/DefaultHandler.hpp>
+#include <xercesc/framework/XMLDocumentHandler.hpp>
+#include <xercesc/framework/psvi/XSElementDeclaration.hpp>
+#include <xercesc/framework/psvi/XSComplexTypeDefinition.hpp>
+#include <xercesc/framework/psvi/XSParticle.hpp>
+#include <xercesc/framework/psvi/XSModelGroup.hpp>
+#include <xercesc/framework/psvi/XSAnnotation.hpp>
+#include <xercesc/framework/psvi/XSValue.hpp>
+#include <xercesc/framework/XMLGrammarPoolImpl.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include <xercesc/dom/DOMLSInput.hpp>
+#include <xercesc/dom/DOMElement.hpp>
+
+#include "../GLM.h"
+#include "Util/XercesString.h"
+#include "ResourceManager.h"
+#include "Entity.h"
+#include "ComponentInfo.h"
+
+class EntityFileHandler
+{
+    friend class EntityFileSAXHandler;
+public:
+    // @param EntityID The entity found
+    // @param EntityID The parent of the entity
+    typedef std::function<void(EntityID, EntityID, const std::string&)> OnStartEntityCallback;
+    void SetStartEntityCallback(OnStartEntityCallback c) { m_OnStartEntityCallback = c; }
+    // @param EntityID The entity the component corresponds to
+    // @param std::string Type name of the component
+    typedef std::function<void(EntityID, const std::string&)> OnStartComponentCallback;
+    void SetStartComponentCallback(OnStartComponentCallback c) { m_OnStartComponentCallback = c; }
+    // @param EntityID Entity 
+    // @param std::string Component name 
+    // @param std::string Field name
+    // @param std::map<std::string, std::string> Field attribute names and values
+    typedef std::function<void(EntityID, const std::string&, const std::string&, const std::map<std::string, std::string>&)> OnStartFieldCallback;
+    void SetStartFieldCallback(OnStartFieldCallback c) { m_OnStartFieldCallback = c; }
+    // @param EntityID Entity 
+    // @param std::string Component name 
+    // @param std::string Field name
+    // @param char* Field data
+    typedef std::function<void(EntityID, const std::string&, const std::string&, const char*)> OnStartFieldDataCallback;
+    void SetStartFieldDataCallback(OnStartFieldDataCallback c) { m_OnStartFieldDataCallback = c; }
+
+private:
+    OnStartEntityCallback m_OnStartEntityCallback = nullptr;
+    OnStartComponentCallback m_OnStartComponentCallback = nullptr;
+    OnStartFieldCallback m_OnStartFieldCallback = nullptr;
+    OnStartFieldDataCallback m_OnStartFieldDataCallback = nullptr;
+};
+
+class EntityFileSAXHandler : public xercesc::DefaultHandler
+{
+public:
+    enum class State
+    {
+        Unknown,
+        Entity,
+        Component,
+        ComponentField
+    };
+
+    EntityFileSAXHandler(const EntityFileHandler* handler, xercesc::SAX2XMLReader* reader);
+
+    void startElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname, const xercesc::Attributes& attrs) override;
+    void characters(const XMLCh* const chars, const XMLSize_t length) override;
+    void endElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname) override;
+
+    void warning(const xercesc::SAXParseException& e);
+    void error(const xercesc::SAXParseException& e);
+    void fatalError(const xercesc::SAXParseException& e);
+
+private:
+    const EntityFileHandler* m_Handler;
+    xercesc::XMLGrammarPool* m_GrammarPool;
+    xercesc::SAX2XMLReader* m_Reader;
+    //State m_CurrentScope = State::Unknown;
+    std::stack<State> m_StateStack;
+    unsigned int m_NextEntityID = 0;
+    std::stack<EntityID> m_EntityStack;
+    std::string m_CurrentComponent;
+    std::string m_CurrentField;
+    std::map<std::string, std::string> m_CurrentAttributes;
+
+    void onStartEntity(const xercesc::Attributes& attrs); 
+    void onEndEntity();
+    void onStartEntityRef(const xercesc::Attributes& attrs);
+    void onStartComponent(const std::string& name);
+    void onEndComponent(const std::string& name);
+    void onStartComponentField(const std::string& field, const xercesc::Attributes& attrs);
+    void onEndComponentField(const std::string& field);
+    void onFieldData(char* data);
+};
+
+class EntityFileXMLErrorHandler : public xercesc::ErrorHandler
+{
+public:
+	void warning(const xercesc::SAXParseException& e) override
+	{
+		reportParseException("Warning", e);
+	}
+	void error(const xercesc::SAXParseException& e) override
+	{
+		reportParseException("Error", e);
+	}
+	void fatalError(const xercesc::SAXParseException& e) override
+	{
+		reportParseException("FATAL ERROR", e);
+	}
+	void resetErrors() override { }
+
+private:
+	void reportParseException(std::string type, const xercesc::SAXParseException& e)
+	{
+		char* message = xercesc::XMLString::transcode(e.getMessage());
+		char* systemID = xercesc::XMLString::transcode(e.getSystemId());
+		std::cerr << systemID << ":" << e.getLineNumber() << ":" << e.getColumnNumber() << std::endl;
+		std::cerr << type << ": " << message << std::endl;
+		xercesc::XMLString::release(&systemID);
+		xercesc::XMLString::release(&message);
+	}
+};
+
+class EntityXMLFile : public Resource
+{
+    friend class ResourceManager;
+    friend class EntityFileSAXHandler;
+private:
+    EntityXMLFile(boost::filesystem::path path);
+    ~EntityXMLFile();
+
+public:
+    static unsigned int GetTypeStride(std::string typeName);
+    static void WriteAttributeData(char* outData, const ComponentInfo::Field_t& field, const std::map<std::string, std::string>& attributes);
+    static void WriteValueData(char* outData, const ComponentInfo::Field_t& field, const char* valueData);
+
+    xercesc::XMLGrammarPool* GrammarPool() const { return m_GrammarPool; }
+
+    void Parse(const EntityFileHandler* handler) const;
+
+private:
+    boost::filesystem::path m_FilePath;
+    xercesc::XMLGrammarPool* m_GrammarPool;
+    xercesc::SAX2XMLReader* m_SAX2XMLReader;
+	//std::map<std::string, ::ComponentInfo> m_ComponentInfo;
+    //std::vector<std::string> m_EntityReferences;
+
+    static void setReaderFeatures(xercesc::SAX2XMLReader* reader);
+};
+
+#endif

include/Engine/Core/EntityXMLFileParser.h

@@ -1,18 +1,19 @@
-#ifndef EntityFileParser_h__
+#ifndef EntityXMLFileParser_h__
-#define EntityFileParser_h__
+#define EntityXMLFileParser_h__
 
-#include "EntityFile.h"
+#include "EntityXMLFile.h"
 #include "World.h"
 
-class EntityFileParser
+class EntityXMLFileParser
 {
+    friend class EntityFile;
 public:
-    EntityFileParser(const EntityFile* entityFile);
+    EntityXMLFileParser(const EntityXMLFile* entityFile);
-
-    EntityID MergeEntities(World* world, EntityID baseParent = EntityID_Invalid);
 
 private:
-    const EntityFile* m_EntityFile;
+    EntityID MergeEntities(World* world, EntityID baseParent = EntityID_Invalid);
+
+    const EntityXMLFile* m_EntityFile;
     EntityFileHandler m_Handler;
     World* m_World = nullptr;
     EntityID m_FirstEntity = EntityID_Invalid;

include/Engine/Core/EntityXMLFilePreprocessor.h

@@ -1,5 +1,5 @@
-#ifndef EntityFilePreprocessor_h__
+#ifndef EntityXMLFilePreprocessor_h__
-#define EntityFilePreprocessor_h__
+#define EntityXMLFilePreprocessor_h__
 
 #include <xercesc/framework/psvi/XSElementDeclaration.hpp>
 #include <xercesc/framework/psvi/XSComplexTypeDefinition.hpp>
@@ -17,17 +17,18 @@
 #include "Util/XercesString.h"
 #include "ResourceManager.h"
 #include "World.h"
-#include "EntityFile.h"
+#include "EntityXMLFile.h"
 
-class EntityFilePreprocessor
+class EntityXMLFilePreprocessor
 {
+    friend class EntityFile;
 public:
-    EntityFilePreprocessor(const EntityFile* entityFile);
+    EntityXMLFilePreprocessor(const EntityXMLFile* entityFile);
-
-    void RegisterComponents(World* world);
 
 private:
-    const EntityFile* m_EntityFile;
+    void RegisterComponents(World* world);
+
+    const EntityXMLFile* m_EntityFile;
     std::map<std::string, unsigned int> m_ComponentCounts;
 	std::map<std::string, ComponentInfo> m_ComponentInfo;
 

include/Engine/Core/EntityXMLFileWriter.h

@@ -1,5 +1,5 @@
-#ifndef EntityFileWriter_h__
+#ifndef EntityXMLFileWriter_h__
-#define EntityFileWriter_h__
+#define EntityXMLFileWriter_h__
 
 #include <boost/filesystem.hpp>
 #include <xercesc/dom/DOM.hpp>
@@ -8,13 +8,13 @@
 #include <xercesc/framework/LocalFileFormatTarget.hpp>
 
 #include "Util/XercesString.h"
-#include "EntityFile.h"
+#include "EntityXMLFile.h"
 #include "World.h"
 
-class EntityFileWriter
+class EntityXMLFileWriter
 {
 public:
-    EntityFileWriter(boost::filesystem::path file)
+    EntityXMLFileWriter(boost::filesystem::path file)
         : m_FilePath(file)
     {
         using namespace xercesc;

include/Engine/Core/MemoryPool.h

@@ -118,9 +118,6 @@ public:
 		else {
 			m_ExtraMemory.push_back((char*)malloc(m_Stride));
 			//We should preferably not enter here to avoid performance issues. Set more numMaxElements in constructor instead.
-            if (!DisableMemoryPool::Value) {
-			    LOG_DEBUG("Allocated slots exceed Pool size, extra memory allocated dynamically. Pool size: %u, dynamic size: %u.", m_NumSlots, m_ExtraMemory.size());
-            }
 			return m_ExtraMemory.back();
 		}
 	}

include/Engine/Core/World.h

@@ -19,13 +19,13 @@ public:
     World(const World& other);
 
     // Create empty entity
-    EntityID CreateEntity(EntityID parent = 0);
+    EntityID CreateEntity(EntityID parent = EntityID_Invalid);
     // Delete entity and all components within
     void DeleteEntity(EntityID entity);
     // Check if an entity exists
     bool ValidEntity(EntityID entity) const;
     // Register a component type and allocate space for it
-    void RegisterComponent(ComponentInfo& ci);
+    void RegisterComponent(const ComponentInfo& ci);
     // Attach a component to an entity and fill it with default values
     ComponentWrapper AttachComponent(EntityID entity, const std::string& componentType);
     // Check if an entity has a component
@@ -53,6 +53,10 @@ public:
     // Get the first entity in the world with the name.
     EntityWrapper GetFirstEntityByName(const std::string& name);
 
+    // Merge another world into this one
+    // Returns a map that maps entities from the other world to their copies in this one
+    std::unordered_map<EntityID, EntityID> Merge(const World* other);
+
 private:
     EventBroker* m_EventBroker = nullptr;
     EntityID m_CurrentEntityID = 0;

include/Engine/Editor/EditorSystem.h

@@ -5,9 +5,8 @@
 #include "../Core/World.h"
 #include "../Core/SystemPipeline.h"
 #include "../Core/ResourceManager.h"
-#include "../Core/EntityFilePreprocessor.h"
+#include "../Core/EntityFile.h"
-#include "../Core/EntityFileParser.h"
+#include "../Core/EntityXMLFileWriter.h"
-#include "../Core/EntityFileWriter.h"
 #include "../Core/EMousePress.h"
 #include "../Input/EInputCommand.h"
 #include "EditorGUI.h"

include/Game/Game.h

@@ -13,13 +13,13 @@
 #include "Input/KeyboardInputHandler.h"
 #include "Input/MouseInputHandler.h"
 #include "Core/EKeyDown.h"
-#include "Core/EntityFilePreprocessor.h"
+#include "Core/EntityXMLFilePreprocessor.h"
 #include "Core/SystemPipeline.h"
 #include "Systems/ExplosionEffectSystem.h"
 #include "Editor/EditorSystem.h"
-#include "Core/EntityFile.h"
+#include "Core/EntityXMLFile.h"
 #include "Rendering/RenderSystem.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityXMLFileParser.h"
 #include "Core/Octree.h"
 #include "Rendering/Font.h"
 #include "Systems/InterpolationSystem.h"

include/Game/Systems/AmmoPickupSystem.h

@@ -4,7 +4,7 @@
 #include "Core/System.h"
 #include "Core/Transform.h"
 #include "Core/ResourceManager.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityFile.h"
 #include "Core/EPickupSpawned.h"
 #include "Core/EAmmoPickup.h"
 #include "Engine/Collision/ETrigger.h"

include/Game/Systems/BoostSystem.h

@@ -3,7 +3,7 @@
 
 #include "Core/System.h"
 #include "Core/ResourceManager.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityFile.h"
 #include "Core/EPlayerDamage.h"
 #include "Common.h"
 

include/Game/Systems/DamageIndicatorSystem.h

@@ -4,7 +4,7 @@
 #include "Core/System.h"
 #include "Core/Transform.h"
 #include "Core/ResourceManager.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityFile.h"
 #include "Core/EPlayerDamage.h"
 #include "Common.h"
 #include <tuple>

include/Game/Systems/PickupSpawnSystem.h

@@ -4,7 +4,7 @@
 #include "Core/System.h"
 #include "Core/Transform.h"
 #include "Core/ResourceManager.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityFile.h"
 #include "Core/EPickupSpawned.h"
 #include "Core/EPlayerHealthPickup.h"
 #include "Engine/Collision/ETrigger.h"

include/Game/Systems/PlayerDeathSystem.h

@@ -6,10 +6,7 @@
 #include "GLM.h"
 #include "Rendering/ESetCamera.h"
 #include "Core/ConfigFile.h"
-
 #include "Core/EntityFile.h"
-#include "Core/EntityFileParser.h"
-
 #include "Core/EPlayerDeath.h"
 #include "Core/EEntityDeleted.h"
 

include/Game/Systems/PlayerMovementSystem.h

@@ -6,9 +6,7 @@
 #include <imgui/imgui.h>
 #include "Events/EDoubleJump.h"
 #include "../Engine/Sound/EPlaySoundOnEntity.h"
-
 #include "Core/EntityFile.h"
-#include "Core/EntityFileParser.h"
 
 class PlayerMovementSystem : public ImpureSystem
 {

include/Game/Systems/SpawnerSystem.h

@@ -7,8 +7,7 @@
 #include "Core/System.h"
 #include "Events/ESpawnerSpawn.h"
 #include "Core/Transform.h"
-#include "Core/ResourceManager.h"
+#include "Core/EntityFile.h"
-#include "Core/EntityFileParser.h"
 
 class SpawnerSystem : public System
 {

include/Game/Systems/Weapon/WeaponSystem.h

@@ -9,8 +9,8 @@
 #include "Core/EShoot.h"
 #include "Core/EPlayerSpawned.h"
 #include "Input/EInputCommand.h"
-#include "Core/EntityFile.h"
+#include "Core/EntityXMLFile.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityXMLFileParser.h"
 #include "Core/Octree.h"
 #include "Collision/EntityAABB.h"
 #include "Systems/SpawnerSystem.h"

resources/Shaders/ForwardPlusSplatMapRGBShieldCheck.frag.glsl

@@ -40,7 +40,6 @@ layout (binding = 10) uniform sampler2D SpecularMapTexture3;
 layout (binding = 11) uniform sampler2D GlowMapTexture1;
 layout (binding = 12) uniform sampler2D GlowMapTexture2;
 layout (binding = 13) uniform sampler2D GlowMapTexture3;
-layout (binding = 13) uniform sampler2D GlowMapTexture3;
 layout (binding = 31) uniform samplerCube ShieldBuffer;
 
 #define TILE_SIZE 16

src/Engine/Core/EntityFile.cpp

@@ -1,291 +1,25 @@
 #include "Core/EntityFile.h"
 
-EntityFile::EntityFile(boost::filesystem::path path)
+EntityFile::EntityFile(std::string path)
-    : m_FilePath(path)
 {
-    using namespace xercesc;
+    EntityXMLFile* xml = ResourceManager::Load<EntityXMLFile>(path);
-    XMLPlatformUtils::Initialize();
-    m_GrammarPool = new XMLGrammarPoolImpl();
-    m_SAX2XMLReader = XMLReaderFactory::createXMLReader(XMLPlatformUtils::fgMemoryManager, m_GrammarPool);
-}
 
-EntityFile::~EntityFile()
+    EntityXMLFilePreprocessor preprocessor(xml);
-{
+    preprocessor.RegisterComponents(this);
-    delete m_SAX2XMLReader;
-    delete m_GrammarPool;
-    xercesc::XMLPlatformUtils::Terminate();
-}
 
-void EntityFile::Parse(const EntityFileHandler* handler) const
+    EntityXMLFileParser parser(xml);
-{
+    m_RootEntity = parser.MergeEntities(this);
-    using namespace xercesc;
 
-    EntityFileSAXHandler saxHandler(handler, m_SAX2XMLReader);
+    if (m_RootEntity == EntityID_Invalid) {
-    setReaderFeatures(m_SAX2XMLReader);
+        ResourceManager::Release("EntityXMLFile", path);
-    m_SAX2XMLReader->setContentHandler(&saxHandler);
+        throw Resource::FailedLoadingException("Failed to merge entities; root entity is invalid");
-    m_SAX2XMLReader->setErrorHandler(&saxHandler);
-    m_SAX2XMLReader->setDeclarationHandler(&saxHandler);
-    m_SAX2XMLReader->parse(m_FilePath.string().c_str());
-}
-
-void EntityFile::setReaderFeatures(xercesc::SAX2XMLReader* reader)
-{
-    using namespace xercesc;
-    reader->setFeature(XMLUni::fgXercesCacheGrammarFromParse, true);
-    reader->setFeature(XMLUni::fgXercesUseCachedGrammarInParse, true);
-    reader->setFeature(XMLUni::fgSAX2CoreValidation, true);
-    reader->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);
-    reader->setFeature(XMLUni::fgXercesSchema, true);
-    reader->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
-    reader->setFeature(XMLUni::fgXercesCalculateSrcOfs, true);
-    reader->setFeature(XMLUni::fgXercesIdentityConstraintChecking, true);
-}
-
-unsigned int EntityFile::GetTypeStride(std::string typeName)
-{
-    std::map<std::string, unsigned int> typeStrides{
-        { "bool", sizeof(bool) },
-        { "int", sizeof(int) },
-        { "float", sizeof(float) },
-        { "double", sizeof(double) },
-        { "string", sizeof(std::string) },
-        { "enum", sizeof(ComponentInfo::EnumType) },
-        { "Vector", sizeof(glm::vec3) },
-        { "Quaternion", sizeof(glm::quat) },
-        { "Color", sizeof(glm::vec4) }
-    };
-
-    auto it = typeStrides.find(typeName);
-    return (it != typeStrides.end()) ? it->second : 0;
-}
-
-void EntityFile::WriteAttributeData(char* outData, const ComponentInfo::Field_t& field, const std::map<std::string, std::string>& attributes)
-{
-    if (field.Type == "Vector") {
-        glm::vec3 vec;
-        vec.x = boost::lexical_cast<float>(attributes.at("X"));
-        vec.y = boost::lexical_cast<float>(attributes.at("Y"));
-        vec.z = boost::lexical_cast<float>(attributes.at("Z"));
-        memcpy(outData, reinterpret_cast<char*>(&vec), field.Stride);
-    } else if (field.Type == "Color") {
-        glm::vec4 vec;
-        vec.r = boost::lexical_cast<float>(attributes.at("R"));
-        vec.g = boost::lexical_cast<float>(attributes.at("G"));
-        vec.b = boost::lexical_cast<float>(attributes.at("B"));
-        vec.a = boost::lexical_cast<float>(attributes.at("A"));
-        memcpy(outData, reinterpret_cast<char*>(&vec), field.Stride);
-    } else if (field.Type == "Quaternion") {
-        glm::quat q;
-        q.x = boost::lexical_cast<float>(attributes.at("X"));
-        q.y = boost::lexical_cast<float>(attributes.at("Y"));
-        q.z = boost::lexical_cast<float>(attributes.at("Z"));
-        q.w = boost::lexical_cast<float>(attributes.at("W"));
-        memcpy(outData, reinterpret_cast<char*>(&q), field.Stride);
-    } else if (!attributes.empty()) {
-        LOG_WARNING("%i attributes not handled by any type conversion!", attributes.size());
-    }
-}
-
-void EntityFile::WriteValueData(char* outData, const ComponentInfo::Field_t& field, const char* valueData)
-{
-    // Catch and ignore casting errors so whitespace around string enums won't mess anything up
-    try {
-        if (field.Type == "int") {
-            int value = boost::lexical_cast<int>(valueData);
-            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
-        } else if (field.Type == "enum") {
-            ComponentInfo::EnumType value = boost::lexical_cast<ComponentInfo::EnumType>(valueData);
-            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
-        } else if (field.Type == "float") {
-            float value = boost::lexical_cast<float>(valueData);
-            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
-        } else if (field.Type == "double") {
-            double value = boost::lexical_cast<double>(valueData);
-            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
-        } else if (field.Type == "bool") {
-            bool value = (valueData[0] == 't'); // Lazy bool evaluation
-            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
-        } else if (field.Type == "string") {
-            new (outData) std::string(valueData);
-        } else {
-            LOG_WARNING("Unknown value data type: %s", field.Type.c_str());
-        }
-    } catch (const boost::bad_lexical_cast&) { }
-}
-
-EntityFileSAXHandler::EntityFileSAXHandler(const EntityFileHandler* handler, xercesc::SAX2XMLReader* reader) 
-    : m_Handler(handler)
-    , m_Reader(reader)
-{
-    // 0 is imaginary base parent
-    m_EntityStack.push(0);
-    m_StateStack.push(State::Unknown);
-}
-
-void EntityFileSAXHandler::startElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname, const xercesc::Attributes& attrs)
-{
-    std::string name = XS::ToString(_localName);
-
-    if (m_StateStack.top() == State::Unknown || m_StateStack.top() == State::Entity) {
-        if (name == "Entity") {
-            m_StateStack.push(State::Entity);
-            onStartEntity(attrs);
-            return;
-        }
-        if (name == "EntityRef") {
-            onStartEntityRef(attrs);
-            return;
-        }
     }
 
-    std::string uri = XS::ToString(_uri);
+    ResourceManager::Release("EntityXMLFile", path);
-    if (m_StateStack.top() == State::Entity) {
-        if (uri == "components") {
-            m_StateStack.push(State::Component);
-            onStartComponent(name);
-            return;
-        }
-    }
-
-    if (m_StateStack.top() == State::Component) {
-        m_StateStack.push(State::ComponentField);
-        onStartComponentField(name, attrs);
-        return;
-    }
 }
 
-void EntityFileSAXHandler::endElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname)
+EntityWrapper EntityFile::MergeInto(World* other)
 {
-    std::string name = XS::ToString(_localName);
+    auto mapping = other->Merge(this);
-    if (m_StateStack.top() == State::Entity) {
+    return EntityWrapper(other, mapping.at(m_RootEntity));
-        if (name == "Entity") {
-            m_StateStack.pop();
-            onEndEntity();
-            return;
-        }
-    }
-
-    std::string uri = XS::ToString(_uri);
-    if (m_StateStack.top() == State::Component) {
-        //if (uri == "components") {
-        m_StateStack.pop();
-        onEndComponent(name);
-        return;
-        //}
-    }
-
-    if (m_StateStack.top() == State::ComponentField && name == m_CurrentField) {
-        m_StateStack.pop();
-        onEndComponentField(name);
-        return;
-    }
-}
-
-void EntityFileSAXHandler::characters(const XMLCh* const chars, const XMLSize_t length)
-{
-    if (m_StateStack.top() == State::ComponentField) {
-        char* transcoded = xercesc::XMLString::transcode(chars);
-        onFieldData(transcoded);
-    }
-}
-
-void EntityFileSAXHandler::fatalError(const xercesc::SAXParseException& e)
-{
-    std::string message = XS::ToString(e.getMessage());
-    std::string systemId = XS::ToString(e.getSystemId());
-    XMLFileLoc line = e.getLineNumber();
-    XMLFileLoc column = e.getColumnNumber();
-    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tFatal Error: %s", systemId.c_str(), line, column, message.c_str());
-}
-
-void EntityFileSAXHandler::error(const xercesc::SAXParseException& e)
-{
-    std::string message = XS::ToString(e.getMessage());
-    std::string systemId = XS::ToString(e.getSystemId());
-    XMLFileLoc line = e.getLineNumber();
-    XMLFileLoc column = e.getColumnNumber();
-    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tError: %s", systemId.c_str(), line, column, message.c_str());
-}
-
-void EntityFileSAXHandler::warning(const xercesc::SAXParseException& e)
-{
-    std::string message = XS::ToString(e.getMessage());
-    std::string systemId = XS::ToString(e.getSystemId());
-    XMLFileLoc line = e.getLineNumber();
-    XMLFileLoc column = e.getColumnNumber();
-    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tWarning: %s", systemId.c_str(), line, column, message.c_str());
-}
-
-void EntityFileSAXHandler::onStartEntity(const xercesc::Attributes& attrs)
-{
-    EntityID parent = m_EntityStack.top();
-
-    if (m_Handler->m_OnStartEntityCallback) {
-        std::string name;
-        auto xName = attrs.getValue(XS::ToXMLCh("name"));
-        if (xName != nullptr) {
-            name = XS::ToString(xName);
-        }
-        m_Handler->m_OnStartEntityCallback(m_NextEntityID, parent, name);
-    }
-
-    m_EntityStack.push(m_NextEntityID);
-    m_NextEntityID++;
-}
-
-void EntityFileSAXHandler::onEndEntity()
-{
-    m_EntityStack.pop();
-}
-
-void EntityFileSAXHandler::onStartEntityRef(const xercesc::Attributes& attrs)
-{
-    std::string path = XS::ToString(attrs.getValue(XS::ToXMLCh("file")));
-
-    xercesc::SAX2XMLReader* reader = xercesc::XMLReaderFactory::createXMLReader();
-    EntityFile::setReaderFeatures(reader);
-    reader->setContentHandler(this);
-    reader->setErrorHandler(this);
-    reader->parse(path.c_str());
-    delete reader;
-}
-
-void EntityFileSAXHandler::onStartComponentField(const std::string& field, const xercesc::Attributes& attrs)
-{
-    //LOG_DEBUG("        Field: %s", field.c_str());
-    m_CurrentField = field;
-    m_CurrentAttributes.clear();
-    for (int i = 0; i < attrs.getLength(); i++) {
-        auto name = attrs.getQName(i);
-        auto value = attrs.getValue(name);
-        //LOG_DEBUG("            %s = %s", (char*)XS::ToString(name), (char*)XS::ToString(value));
-        m_CurrentAttributes[XS::ToString(name).operator std::string()] = XS::ToString(value).operator std::string();
-    }
-
-    if (m_Handler->m_OnStartFieldCallback) {
-        m_Handler->m_OnStartFieldCallback(m_EntityStack.top(), m_CurrentComponent, field, m_CurrentAttributes);
-    }
-}
-
-void EntityFileSAXHandler::onEndComponent(const std::string& name) { }
-
-void EntityFileSAXHandler::onStartComponent(const std::string& name)
-{
-    //LOG_DEBUG("    Component: %s", name.c_str());
-    m_CurrentComponent = name;
-    if (m_Handler->m_OnStartComponentCallback) {
-        m_Handler->m_OnStartComponentCallback(m_EntityStack.top(), name);
-    }
-}
-
-void EntityFileSAXHandler::onEndComponentField(const std::string& field) { }
-
-void EntityFileSAXHandler::onFieldData(char* data)
-{
-    //LOG_DEBUG("            Data: %s", data);
-    if (m_Handler->m_OnStartFieldDataCallback) {
-        m_Handler->m_OnStartFieldDataCallback(m_EntityStack.top(), m_CurrentComponent, m_CurrentField, data);
-    }
-
-    xercesc::XMLString::release(&data);
 }

src/Engine/Core/EntityXMLFile.cpp

@@ -0,0 +1,291 @@
+#include "Core/EntityXMLFile.h"
+
+EntityXMLFile::EntityXMLFile(boost::filesystem::path path)
+    : m_FilePath(path)
+{
+    using namespace xercesc;
+    XMLPlatformUtils::Initialize();
+    m_GrammarPool = new XMLGrammarPoolImpl();
+    m_SAX2XMLReader = XMLReaderFactory::createXMLReader(XMLPlatformUtils::fgMemoryManager, m_GrammarPool);
+}
+
+EntityXMLFile::~EntityXMLFile()
+{
+    delete m_SAX2XMLReader;
+    delete m_GrammarPool;
+    xercesc::XMLPlatformUtils::Terminate();
+}
+
+void EntityXMLFile::Parse(const EntityFileHandler* handler) const
+{
+    using namespace xercesc;
+
+    EntityFileSAXHandler saxHandler(handler, m_SAX2XMLReader);
+    setReaderFeatures(m_SAX2XMLReader);
+    m_SAX2XMLReader->setContentHandler(&saxHandler);
+    m_SAX2XMLReader->setErrorHandler(&saxHandler);
+    m_SAX2XMLReader->setDeclarationHandler(&saxHandler);
+    m_SAX2XMLReader->parse(m_FilePath.string().c_str());
+}
+
+void EntityXMLFile::setReaderFeatures(xercesc::SAX2XMLReader* reader)
+{
+    using namespace xercesc;
+    reader->setFeature(XMLUni::fgXercesCacheGrammarFromParse, true);
+    reader->setFeature(XMLUni::fgXercesUseCachedGrammarInParse, true);
+    reader->setFeature(XMLUni::fgSAX2CoreValidation, true);
+    reader->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);
+    reader->setFeature(XMLUni::fgXercesSchema, true);
+    reader->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
+    reader->setFeature(XMLUni::fgXercesCalculateSrcOfs, true);
+    reader->setFeature(XMLUni::fgXercesIdentityConstraintChecking, true);
+}
+
+unsigned int EntityXMLFile::GetTypeStride(std::string typeName)
+{
+    std::map<std::string, unsigned int> typeStrides{
+        { "bool", sizeof(bool) },
+        { "int", sizeof(int) },
+        { "float", sizeof(float) },
+        { "double", sizeof(double) },
+        { "string", sizeof(std::string) },
+        { "enum", sizeof(ComponentInfo::EnumType) },
+        { "Vector", sizeof(glm::vec3) },
+        { "Quaternion", sizeof(glm::quat) },
+        { "Color", sizeof(glm::vec4) }
+    };
+
+    auto it = typeStrides.find(typeName);
+    return (it != typeStrides.end()) ? it->second : 0;
+}
+
+void EntityXMLFile::WriteAttributeData(char* outData, const ComponentInfo::Field_t& field, const std::map<std::string, std::string>& attributes)
+{
+    if (field.Type == "Vector") {
+        glm::vec3 vec;
+        vec.x = boost::lexical_cast<float>(attributes.at("X"));
+        vec.y = boost::lexical_cast<float>(attributes.at("Y"));
+        vec.z = boost::lexical_cast<float>(attributes.at("Z"));
+        memcpy(outData, reinterpret_cast<char*>(&vec), field.Stride);
+    } else if (field.Type == "Color") {
+        glm::vec4 vec;
+        vec.r = boost::lexical_cast<float>(attributes.at("R"));
+        vec.g = boost::lexical_cast<float>(attributes.at("G"));
+        vec.b = boost::lexical_cast<float>(attributes.at("B"));
+        vec.a = boost::lexical_cast<float>(attributes.at("A"));
+        memcpy(outData, reinterpret_cast<char*>(&vec), field.Stride);
+    } else if (field.Type == "Quaternion") {
+        glm::quat q;
+        q.x = boost::lexical_cast<float>(attributes.at("X"));
+        q.y = boost::lexical_cast<float>(attributes.at("Y"));
+        q.z = boost::lexical_cast<float>(attributes.at("Z"));
+        q.w = boost::lexical_cast<float>(attributes.at("W"));
+        memcpy(outData, reinterpret_cast<char*>(&q), field.Stride);
+    } else if (!attributes.empty()) {
+        LOG_WARNING("%i attributes not handled by any type conversion!", attributes.size());
+    }
+}
+
+void EntityXMLFile::WriteValueData(char* outData, const ComponentInfo::Field_t& field, const char* valueData)
+{
+    // Catch and ignore casting errors so whitespace around string enums won't mess anything up
+    try {
+        if (field.Type == "int") {
+            int value = boost::lexical_cast<int>(valueData);
+            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
+        } else if (field.Type == "enum") {
+            ComponentInfo::EnumType value = boost::lexical_cast<ComponentInfo::EnumType>(valueData);
+            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
+        } else if (field.Type == "float") {
+            float value = boost::lexical_cast<float>(valueData);
+            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
+        } else if (field.Type == "double") {
+            double value = boost::lexical_cast<double>(valueData);
+            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
+        } else if (field.Type == "bool") {
+            bool value = (valueData[0] == 't'); // Lazy bool evaluation
+            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
+        } else if (field.Type == "string") {
+            new (outData) std::string(valueData);
+        } else {
+            LOG_WARNING("Unknown value data type: %s", field.Type.c_str());
+        }
+    } catch (const boost::bad_lexical_cast&) { }
+}
+
+EntityFileSAXHandler::EntityFileSAXHandler(const EntityFileHandler* handler, xercesc::SAX2XMLReader* reader) 
+    : m_Handler(handler)
+    , m_Reader(reader)
+{
+    // 0 is imaginary base parent
+    m_EntityStack.push(0);
+    m_StateStack.push(State::Unknown);
+}
+
+void EntityFileSAXHandler::startElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname, const xercesc::Attributes& attrs)
+{
+    std::string name = XS::ToString(_localName);
+
+    if (m_StateStack.top() == State::Unknown || m_StateStack.top() == State::Entity) {
+        if (name == "Entity") {
+            m_StateStack.push(State::Entity);
+            onStartEntity(attrs);
+            return;
+        }
+        if (name == "EntityRef") {
+            onStartEntityRef(attrs);
+            return;
+        }
+    }
+
+    std::string uri = XS::ToString(_uri);
+    if (m_StateStack.top() == State::Entity) {
+        if (uri == "components") {
+            m_StateStack.push(State::Component);
+            onStartComponent(name);
+            return;
+        }
+    }
+
+    if (m_StateStack.top() == State::Component) {
+        m_StateStack.push(State::ComponentField);
+        onStartComponentField(name, attrs);
+        return;
+    }
+}
+
+void EntityFileSAXHandler::endElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname)
+{
+    std::string name = XS::ToString(_localName);
+    if (m_StateStack.top() == State::Entity) {
+        if (name == "Entity") {
+            m_StateStack.pop();
+            onEndEntity();
+            return;
+        }
+    }
+
+    std::string uri = XS::ToString(_uri);
+    if (m_StateStack.top() == State::Component) {
+        //if (uri == "components") {
+        m_StateStack.pop();
+        onEndComponent(name);
+        return;
+        //}
+    }
+
+    if (m_StateStack.top() == State::ComponentField && name == m_CurrentField) {
+        m_StateStack.pop();
+        onEndComponentField(name);
+        return;
+    }
+}
+
+void EntityFileSAXHandler::characters(const XMLCh* const chars, const XMLSize_t length)
+{
+    if (m_StateStack.top() == State::ComponentField) {
+        char* transcoded = xercesc::XMLString::transcode(chars);
+        onFieldData(transcoded);
+    }
+}
+
+void EntityFileSAXHandler::fatalError(const xercesc::SAXParseException& e)
+{
+    std::string message = XS::ToString(e.getMessage());
+    std::string systemId = XS::ToString(e.getSystemId());
+    XMLFileLoc line = e.getLineNumber();
+    XMLFileLoc column = e.getColumnNumber();
+    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tFatal Error: %s", systemId.c_str(), line, column, message.c_str());
+}
+
+void EntityFileSAXHandler::error(const xercesc::SAXParseException& e)
+{
+    std::string message = XS::ToString(e.getMessage());
+    std::string systemId = XS::ToString(e.getSystemId());
+    XMLFileLoc line = e.getLineNumber();
+    XMLFileLoc column = e.getColumnNumber();
+    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tError: %s", systemId.c_str(), line, column, message.c_str());
+}
+
+void EntityFileSAXHandler::warning(const xercesc::SAXParseException& e)
+{
+    std::string message = XS::ToString(e.getMessage());
+    std::string systemId = XS::ToString(e.getSystemId());
+    XMLFileLoc line = e.getLineNumber();
+    XMLFileLoc column = e.getColumnNumber();
+    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tWarning: %s", systemId.c_str(), line, column, message.c_str());
+}
+
+void EntityFileSAXHandler::onStartEntity(const xercesc::Attributes& attrs)
+{
+    EntityID parent = m_EntityStack.top();
+
+    if (m_Handler->m_OnStartEntityCallback) {
+        std::string name;
+        auto xName = attrs.getValue(XS::ToXMLCh("name"));
+        if (xName != nullptr) {
+            name = XS::ToString(xName);
+        }
+        m_Handler->m_OnStartEntityCallback(m_NextEntityID, parent, name);
+    }
+
+    m_EntityStack.push(m_NextEntityID);
+    m_NextEntityID++;
+}
+
+void EntityFileSAXHandler::onEndEntity()
+{
+    m_EntityStack.pop();
+}
+
+void EntityFileSAXHandler::onStartEntityRef(const xercesc::Attributes& attrs)
+{
+    std::string path = XS::ToString(attrs.getValue(XS::ToXMLCh("file")));
+
+    xercesc::SAX2XMLReader* reader = xercesc::XMLReaderFactory::createXMLReader();
+    EntityXMLFile::setReaderFeatures(reader);
+    reader->setContentHandler(this);
+    reader->setErrorHandler(this);
+    reader->parse(path.c_str());
+    delete reader;
+}
+
+void EntityFileSAXHandler::onStartComponentField(const std::string& field, const xercesc::Attributes& attrs)
+{
+    //LOG_DEBUG("        Field: %s", field.c_str());
+    m_CurrentField = field;
+    m_CurrentAttributes.clear();
+    for (int i = 0; i < attrs.getLength(); i++) {
+        auto name = attrs.getQName(i);
+        auto value = attrs.getValue(name);
+        //LOG_DEBUG("            %s = %s", (char*)XS::ToString(name), (char*)XS::ToString(value));
+        m_CurrentAttributes[XS::ToString(name).operator std::string()] = XS::ToString(value).operator std::string();
+    }
+
+    if (m_Handler->m_OnStartFieldCallback) {
+        m_Handler->m_OnStartFieldCallback(m_EntityStack.top(), m_CurrentComponent, field, m_CurrentAttributes);
+    }
+}
+
+void EntityFileSAXHandler::onEndComponent(const std::string& name) { }
+
+void EntityFileSAXHandler::onStartComponent(const std::string& name)
+{
+    //LOG_DEBUG("    Component: %s", name.c_str());
+    m_CurrentComponent = name;
+    if (m_Handler->m_OnStartComponentCallback) {
+        m_Handler->m_OnStartComponentCallback(m_EntityStack.top(), name);
+    }
+}
+
+void EntityFileSAXHandler::onEndComponentField(const std::string& field) { }
+
+void EntityFileSAXHandler::onFieldData(char* data)
+{
+    //LOG_DEBUG("            Data: %s", data);
+    if (m_Handler->m_OnStartFieldDataCallback) {
+        m_Handler->m_OnStartFieldDataCallback(m_EntityStack.top(), m_CurrentComponent, m_CurrentField, data);
+    }
+
+    xercesc::XMLString::release(&data);
+}

src/Engine/Core/EntityXMLFileParser.cpp

@@ -1,15 +1,15 @@
-#include "Core/EntityFileParser.h"
+#include "Core/EntityXMLFileParser.h"
 
-EntityFileParser::EntityFileParser(const EntityFile* entityFile)
+EntityXMLFileParser::EntityXMLFileParser(const EntityXMLFile* entityFile)
     : m_EntityFile(entityFile)
 {
-    m_Handler.SetStartEntityCallback(std::bind(&EntityFileParser::onStartEntity, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+    m_Handler.SetStartEntityCallback(std::bind(&EntityXMLFileParser::onStartEntity, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
-    m_Handler.SetStartComponentCallback(std::bind(&EntityFileParser::onStartComponent, this, std::placeholders::_1, std::placeholders::_2));
+    m_Handler.SetStartComponentCallback(std::bind(&EntityXMLFileParser::onStartComponent, this, std::placeholders::_1, std::placeholders::_2));
-    m_Handler.SetStartFieldCallback(std::bind(&EntityFileParser::onStartComponentField, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
+    m_Handler.SetStartFieldCallback(std::bind(&EntityXMLFileParser::onStartComponentField, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
-    m_Handler.SetStartFieldDataCallback(std::bind(&EntityFileParser::onFieldData, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
+    m_Handler.SetStartFieldDataCallback(std::bind(&EntityXMLFileParser::onFieldData, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
 }
 
-EntityID EntityFileParser::MergeEntities(World* world, EntityID baseParent /*= EntityID_Invalid */)
+EntityID EntityXMLFileParser::MergeEntities(World* world, EntityID baseParent /*= EntityID_Invalid */)
 {
     m_World = world;
     m_EntityIDMapper[0] = baseParent;
@@ -17,7 +17,7 @@ EntityID EntityFileParser::MergeEntities(World* world, EntityID baseParent /*= E
     return m_FirstEntity;
 }
 
-void EntityFileParser::onStartEntity(EntityID entity, EntityID parent, const std::string& name)
+void EntityXMLFileParser::onStartEntity(EntityID entity, EntityID parent, const std::string& name)
 {
     EntityID realParent = m_EntityIDMapper.at(parent);
     EntityID realEntity = m_World->CreateEntity(realParent);
@@ -31,7 +31,7 @@ void EntityFileParser::onStartEntity(EntityID entity, EntityID parent, const std
     //LOG_DEBUG("Created entity #%i (%i) with parent %i (%i)", entity, realEntity, parent, realParent);
 }
 
-void EntityFileParser::onStartComponent(EntityID entity, const std::string& component)
+void EntityXMLFileParser::onStartComponent(EntityID entity, const std::string& component)
 {
     if (m_World->GetComponentPools().count(component) != 0) {
         EntityID realEntity = m_EntityIDMapper.at(entity);
@@ -42,7 +42,7 @@ void EntityFileParser::onStartComponent(EntityID entity, const std::string& comp
     //LOG_DEBUG("Attached component of type \"%s\" to entity #%i (%i)", component.c_str(), entity, realEntity);
 }
 
-void EntityFileParser::onStartComponentField(EntityID entity, const std::string& componentType, const std::string& fieldName, const std::map<std::string, std::string>& attributes)
+void EntityXMLFileParser::onStartComponentField(EntityID entity, const std::string& componentType, const std::string& fieldName, const std::map<std::string, std::string>& attributes)
 {
     if (m_World->GetComponentPools().count(componentType) == 0) {
         return;
@@ -63,10 +63,10 @@ void EntityFileParser::onStartComponentField(EntityID entity, const std::string&
     //}
 
     char* data = component.Data + field.Offset;
-    EntityFile::WriteAttributeData(data, field, attributes);
+    EntityXMLFile::WriteAttributeData(data, field, attributes);
 }
 
-void EntityFileParser::onFieldData(EntityID entity, const std::string& componentType, const std::string& fieldName, const char* fieldData)
+void EntityXMLFileParser::onFieldData(EntityID entity, const std::string& componentType, const std::string& fieldName, const char* fieldData)
 {
     if (m_World->GetComponentPools().count(componentType) == 0) {
         return;
@@ -80,5 +80,5 @@ void EntityFileParser::onFieldData(EntityID entity, const std::string& component
     auto& field = fieldIt->second;
 
     char* data = component.Data + field.Offset;
-    EntityFile::WriteValueData(data, field, fieldData);
+    EntityXMLFile::WriteValueData(data, field, fieldData);
 }

src/Engine/Core/EntityXMLFilePreprocessor.cpp

@@ -1,10 +1,10 @@
-#include "Core/EntityFilePreprocessor.h"
+#include "Core/EntityXMLFilePreprocessor.h"
 
-EntityFilePreprocessor::EntityFilePreprocessor(const EntityFile* entityFile) 
+EntityXMLFilePreprocessor::EntityXMLFilePreprocessor(const EntityXMLFile* entityFile) 
     : m_EntityFile(entityFile)
 {
     EntityFileHandler handler;
-    handler.SetStartComponentCallback(std::bind(&EntityFilePreprocessor::onStartComponent, this, std::placeholders::_1, std::placeholders::_2));
+    handler.SetStartComponentCallback(std::bind(&EntityXMLFilePreprocessor::onStartComponent, this, std::placeholders::_1, std::placeholders::_2));
     m_EntityFile->Parse(&handler);
 
     //LOG_DEBUG("___ COMPONENT DEFINITIONS ___");
@@ -28,20 +28,20 @@ EntityFilePreprocessor::EntityFilePreprocessor(const EntityFile* entityFile)
     parseDefaults();
 }
 
-void EntityFilePreprocessor::RegisterComponents(World* world)
+void EntityXMLFilePreprocessor::RegisterComponents(World* world)
 {
     for (auto& kv : m_ComponentInfo) {
         world->RegisterComponent(kv.second);
     }
 }
 
-void EntityFilePreprocessor::onStartComponent(EntityID entity, std::string type)
+void EntityXMLFilePreprocessor::onStartComponent(EntityID entity, std::string type)
 {
     //LOG_DEBUG("Component: %s", type.c_str());
     m_ComponentCounts[type]++;
 }
 
-void EntityFilePreprocessor::parseComponentInfo()
+void EntityXMLFilePreprocessor::parseComponentInfo()
 {
     using namespace xercesc;
     EntityFileXMLErrorHandler errorHandler;
@@ -141,9 +141,9 @@ void EntityFilePreprocessor::parseComponentInfo()
             std::string baseType = XS::ToString(elementDeclaration->getTypeDefinition()->getBaseType()->getName());
 
             std::string effectiveType = type;
-            unsigned int stride = EntityFile::GetTypeStride(type);
+            unsigned int stride = EntityXMLFile::GetTypeStride(type);
             if (stride == 0) {
-                stride = EntityFile::GetTypeStride(baseType);
+                stride = EntityXMLFile::GetTypeStride(baseType);
                 if (stride == 0) {
                     LOG_WARNING("Field \"%s\" in component \"%s\" uses unexpected field type \"%s\" with base type \"%s\". Skipping.", name.c_str(), compInfo.Name.c_str(), type.c_str(), baseType.c_str());
                     continue;
@@ -196,7 +196,7 @@ void EntityFilePreprocessor::parseComponentInfo()
     }
 }
 
-void EntityFilePreprocessor::parseDefaults()
+void EntityXMLFilePreprocessor::parseDefaults()
 {
     using namespace xercesc;
 
@@ -261,7 +261,7 @@ void EntityFilePreprocessor::parseDefaults()
                     auto attribItem = attributeMap->item(i);
                     attributes[XS::ToString(attribItem->getNodeName())] = XS::ToString(attribItem->getNodeValue());
                 }
-                EntityFile::WriteAttributeData(data, field, attributes);
+                EntityXMLFile::WriteAttributeData(data, field, attributes);
             }
 
             auto childNode = fieldElement->getFirstChild();
@@ -278,14 +278,14 @@ void EntityFilePreprocessor::parseDefaults()
             // Handle potential field values
             if (childNode->getNodeType() == DOMNode::TEXT_NODE) {
                 char* cstrValue = XMLString::transcode(childNode->getNodeValue());
-                EntityFile::WriteValueData(data, field, cstrValue);
+                EntityXMLFile::WriteValueData(data, field, cstrValue);
                 XMLString::release(&cstrValue);
             }
         }
     }
 }
 
-std::string EntityFilePreprocessor::parseAnnotationXML(const XMLCh* xml)
+std::string EntityXMLFilePreprocessor::parseAnnotationXML(const XMLCh* xml)
 {
     using namespace xercesc;
 

src/Engine/Core/EntityXMLFileWriter.cpp

@@ -1,13 +1,13 @@
-#include "Core/EntityFileWriter.h"
+#include "Core/EntityXMLFileWriter.h"
 
 #define X(str) XS::ToXMLCh(str)
 
-void EntityFileWriter::WriteWorld(World* world)
+void EntityXMLFileWriter::WriteWorld(World* world)
 {
     WriteEntity(world, 0);
 }
 
-void EntityFileWriter::WriteEntity(World* world, EntityID entity)
+void EntityXMLFileWriter::WriteEntity(World* world, EntityID entity)
 {
     using namespace xercesc;
     DOMDocument* doc = m_DOMImplementation->createDocument(nullptr, X("Entity"), nullptr);
@@ -41,7 +41,7 @@ void EntityFileWriter::WriteEntity(World* world, EntityID entity)
     doc->release();
 }
 
-void EntityFileWriter::appendEntityChildren(xercesc::DOMElement* parentElement, const World* world, EntityID entity)
+void EntityXMLFileWriter::appendEntityChildren(xercesc::DOMElement* parentElement, const World* world, EntityID entity)
 {
     using namespace xercesc;
     DOMDocument* doc = parentElement->getOwnerDocument();
@@ -67,7 +67,7 @@ void EntityFileWriter::appendEntityChildren(xercesc::DOMElement* parentElement,
     }
 }
 
-void EntityFileWriter::appentEntityComponents(xercesc::DOMElement* parentElement, const World* world, EntityID entity)
+void EntityXMLFileWriter::appentEntityComponents(xercesc::DOMElement* parentElement, const World* world, EntityID entity)
 {
     using namespace xercesc;
     DOMDocument* doc = parentElement->getOwnerDocument();

src/Engine/Core/World.cpp

@@ -45,7 +45,7 @@ bool World::ValidEntity(EntityID entity) const
     return m_EntityParents.find(entity) != m_EntityParents.end();
 }
 
-void World::RegisterComponent(ComponentInfo& ci)
+void World::RegisterComponent(const ComponentInfo& ci)
 {
     if (m_ComponentPools.find(ci.Name) == m_ComponentPools.end()) {
         m_ComponentPools[ci.Name] = new ComponentPool(ci);
@@ -169,6 +169,45 @@ EntityWrapper World::GetFirstEntityByName(const std::string& name)
     return EntityWrapper::Invalid;
 }
 
+std::unordered_map<EntityID, EntityID> World::Merge(const World* other)
+{
+    std::unordered_map<EntityID, EntityID> oldToNew;
+
+    // Create new entities
+    for (auto& kv : other->m_EntityParents) {
+        EntityID entity = kv.first;
+
+        EntityID newEntity = CreateEntity();
+        SetName(newEntity, other->GetName(entity));
+        oldToNew[entity] = newEntity;
+    }
+    // Fix relationships
+    for (auto& kv : other->m_EntityParents) {
+        EntityID entity = kv.first;
+        EntityID parent = kv.second;
+        if (parent != EntityID_Invalid) {
+            SetParent(oldToNew.at(entity), oldToNew.at(parent));
+        }
+    }
+
+    // Transfer components
+    for (auto& kv : other->m_ComponentPools) {
+        auto& componentType = kv.first;
+        ComponentPool* pool = kv.second;
+        // Register pool if it's not present in world
+        if (m_ComponentPools.count(componentType) == 0) {
+            RegisterComponent(pool->ComponentInfo());
+        }
+        // Copy components
+        for (auto component : *pool) {
+            ComponentWrapper newComponent = AttachComponent(oldToNew.at(component.EntityID), componentType);
+            component.Copy(newComponent);
+        }
+    }
+
+    return oldToNew;
+}
+
 EntityID World::generateEntityID()
 {
     // TODO: Make EntityID generation smarter

src/Engine/Editor/EditorSystem.cpp

@@ -2,6 +2,7 @@
 #include "Core/UniformScaleSystem.h"
 #include "Editor/EditorRenderSystem.h"
 #include "Editor/EditorWidgetSystem.h"
+#include "Core/EntityFile.h"
 
 EditorSystem::EditorSystem(SystemParams params, IRenderer* renderer, RenderFrame* renderFrame) 
     : System(params)
@@ -129,7 +130,7 @@ void EditorSystem::OnEntitySelected(EntityWrapper entity)
 
 void EditorSystem::OnEntitySave(EntityWrapper entity, boost::filesystem::path filePath)
 {
-    EntityFileWriter writer(filePath);
+    EntityXMLFileWriter writer(filePath);
     writer.WriteEntity(entity.World, entity.ID);
 }
 
@@ -260,11 +261,9 @@ EntityWrapper EditorSystem::importEntity(EntityWrapper parent, boost::filesystem
 
     try {
         auto entityFile = ResourceManager::Load<EntityFile>(filePath.string());
-        EntityFilePreprocessor fpp(entityFile);
+        EntityWrapper newEntity = entityFile->MergeInto(parent.World);
-        fpp.RegisterComponents(parent.World);
+        parent.World->SetParent(newEntity.ID, parent.ID);
-        EntityFileParser fp(entityFile);
+        return newEntity;
-        EntityID newEntity = fp.MergeEntities(parent.World, parent.ID);
-        return EntityWrapper(parent.World, newEntity);
     } catch (const std::exception& e) {
         LOG_ERROR("Failed to import entity \"%s\": \"%s\"", filePath.string().c_str(), e.what());
         return EntityWrapper::Invalid;

src/Engine/Rendering/FrameBuffer.cpp

@@ -70,7 +70,7 @@ void FrameBuffer::Generate()
 	}
 	GLERROR("3");
 
-    GLenum* bufferTextures = &attachments[0];
+    GLenum* bufferTextures = attachments.data();
     glDrawBuffers(attachments.size(), bufferTextures);
     if (GLERROR("GLBufferAttachement error")) {
         printf(": AttachmentSize %i", attachments.size());

src/Game/Game.cpp

@@ -11,7 +11,8 @@
 #include "Systems/PlayerSpawnSystem.h"
 #include "Systems/PlayerDeathSystem.h"
 #include "Systems/FloatingEffectSystem.h"
-#include "Core/EntityFileWriter.h"
+#include "Core/EntityFile.h"
+#include "Core/EntityXMLFileWriter.h"
 #include "Game/Systems/CapturePointSystem.h"
 #include "Game/Systems/CapturePointHUDSystem.h"
 #include "Game/Systems/PickupSpawnSystem.h"
@@ -45,6 +46,7 @@ Game::Game(int argc, char* argv[])
     ResourceManager::RegisterType<PNG>("Png");
     ResourceManager::RegisterType<ShaderProgram>("ShaderProgram");
     ResourceManager::RegisterType<EntityFile>("EntityFile");
+    ResourceManager::RegisterType<EntityXMLFile>("EntityXMLFile");
     ResourceManager::RegisterType<Font>("FontFile");
 
     m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
@@ -81,10 +83,7 @@ Game::Game(int argc, char* argv[])
     std::string mapToLoad = m_Config->Get<std::string>("Debug.LoadMap", "");
     if (!mapToLoad.empty()) {
         auto file = ResourceManager::Load<EntityFile>(mapToLoad);
-        EntityFilePreprocessor fpp(file);
+        file->MergeInto(m_World);
-        fpp.RegisterComponents(m_World);
-        EntityFileParser fp(file);
-        fp.MergeEntities(m_World);
     }
 
     // Create the sound manager

src/Game/Systems/AmmoPickupSystem.cpp

@@ -21,16 +21,15 @@ void AmmoPickupSystem::Update(double dt)
             somePickup.DecreaseThisRespawnTimer -= dt;
             if (somePickup.DecreaseThisRespawnTimer < 0.0) {
                 auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/AmmoPickup.xml");
-                EntityFileParser parser(entityFile);
+                EntityWrapper ammoPickup = entityFile->MergeInto(m_World);
-                EntityID ammoPickupID = parser.MergeEntities(m_World);
 
                 //let the world know a pickup has spawned
                 Events::PickupSpawned ePickupSpawned;
-                ePickupSpawned.Pickup = EntityWrapper(m_World, ammoPickupID);
+                ePickupSpawned.Pickup = ammoPickup;
                 m_EventBroker->Publish(ePickupSpawned);
 
                 //copy values from the old entity to the new entity
-                auto& newAmmoPickupEntity = EntityWrapper(m_World, ammoPickupID);
+                auto& newAmmoPickupEntity = ammoPickup;
                 newAmmoPickupEntity["Transform"]["Position"] = somePickup.Pos;
                 newAmmoPickupEntity["AmmoPickup"]["AmmoGain"] = somePickup.AmmoGain;
                 newAmmoPickupEntity["AmmoPickup"]["RespawnTimer"] = somePickup.RespawnTimer;

src/Game/Systems/BoostSystem.cpp

@@ -39,10 +39,9 @@ bool BoostSystem::OnPlayerDamage(Events::PlayerDamage& e)
     }
     //load boost XML file, set it entity parented with the victim player
     auto entityFile = ResourceManager::Load<EntityFile>(classXML);
-    EntityFileParser parser(entityFile);
+    EntityWrapper boostAssaultEntity = entityFile->MergeInto(m_World);
-    EntityID boostAssaultEntity = parser.MergeEntities(m_World);
+    m_World->SetName(boostAssaultEntity.ID, className);
-    m_World->SetName(boostAssaultEntity, className);
+    m_World->SetParent(boostAssaultEntity.ID, e.Victim.ID);
-    m_World->SetParent(boostAssaultEntity, e.Victim.ID);
 
     return true;
 }

src/Game/Systems/DamageIndicatorSystem.cpp

@@ -9,7 +9,7 @@ DamageIndicatorSystem::DamageIndicatorSystem(SystemParams params)
 
     //load texture to cache
     auto texture = CommonFunctions::LoadTexture("Textures/DamageIndicator.png", false);
-    auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/DamageIndicator.xml");
+    auto entityFile = ResourceManager::Load<EntityXMLFile>("Schema/Entities/DamageIndicator.xml");
 }
 
 void DamageIndicatorSystem::Update(double dt) {
@@ -50,15 +50,13 @@ bool DamageIndicatorSystem::OnPlayerDamage(Events::PlayerDamage& e)
 
     //load & set the "2d" sprite
     auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/DamageIndicator.xml");
-    EntityFileParser parser(entityFile);
+    EntityWrapper sprite = entityFile->MergeInto(m_World);
-    EntityID spriteID = parser.MergeEntities(m_World);
+    m_World->SetParent(sprite.ID, m_CurrentCamera);
-    m_World->SetParent(spriteID, m_CurrentCamera);
-    auto spriteWrapper = EntityWrapper(m_World, spriteID);
     //simply set the rotation z-wise to the angleBetweenVectors
-    spriteWrapper["Transform"]["Orientation"] = glm::vec3(0, 0, angleBetweenVectors);
+    sprite["Transform"]["Orientation"] = glm::vec3(0, 0, angleBetweenVectors);
 
     if (!IsServer) {
-        updateDamageIndicatorVector.emplace_back(spriteWrapper, inflictorPos);
+        updateDamageIndicatorVector.emplace_back(sprite, inflictorPos);
     }
 
     return true;
@@ -127,8 +125,8 @@ glm::vec3 DamageIndicatorSystem::DamageIndicatorTest(EntityWrapper player) {
      auto inflictorPos = glm::vec3(currentPos.x + testVar*6.0f, currentPos.y, currentPos.z + testVar2*6.0f);
 
     //load the explosioneffect XML
-    auto deathEffect = ResourceManager::Load<EntityFile>("Schema/Entities/PlayerDeathExplosionWithCamera.xml");
+    auto deathEffect = ResourceManager::Load<EntityXMLFile>("Schema/Entities/PlayerDeathExplosionWithCamera.xml");
-    EntityFileParser parser(deathEffect);
+    EntityXMLFileParser parser(deathEffect);
     EntityID deathEffectID = parser.MergeEntities(m_World);
     EntityWrapper deathEffectEW = EntityWrapper(m_World, deathEffectID);
 

src/Game/Systems/PickupSpawnSystem.cpp

@@ -19,16 +19,15 @@ void PickupSpawnSystem::Update(double dt)
             if (somePickup.DecreaseThisRespawnTimer < 0.0) {
                 //spawn the new healthPickup
                 auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/HealthPickup.xml");
-                EntityFileParser parser(entityFile);
+                EntityWrapper healthPickup = entityFile->MergeInto(m_World);
-                EntityID healthPickupID = parser.MergeEntities(m_World);
 
                 //let the world know a pickup has spawned (graphics effects, etc)
                 Events::PickupSpawned ePickupSpawned;
-                ePickupSpawned.Pickup = EntityWrapper(m_World, healthPickupID);
+                ePickupSpawned.Pickup = healthPickup;
                 m_EventBroker->Publish(ePickupSpawned);
 
                 //copy values from the old entity to the new entity
-                auto& newHealthPickupEntity = EntityWrapper(m_World, healthPickupID);
+                auto& newHealthPickupEntity = healthPickup;
                 newHealthPickupEntity["Transform"]["Position"] = somePickup.Pos;
                 newHealthPickupEntity["HealthPickup"]["HealthGain"] = somePickup.HealthGain;
                 newHealthPickupEntity["HealthPickup"]["RespawnTimer"] = somePickup.RespawnTimer;

src/Game/Systems/PlayerDeathSystem.cpp

@@ -28,10 +28,8 @@ bool PlayerDeathSystem::OnPlayerDeath(Events::PlayerDeath& e)
 void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
 {
     //load the explosioneffect XML
-    auto deathEffect = ResourceManager::Load<EntityFile>("Schema/Entities/PlayerDeathExplosionWithCamera.xml");
+    auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/PlayerDeathExplosionWithCamera.xml");
-    EntityFileParser parser(deathEffect);
+    EntityWrapper deathEffectEW = entityFile->MergeInto(m_World);
-    EntityID deathEffectID = parser.MergeEntities(m_World);
-    EntityWrapper deathEffectEW = EntityWrapper(m_World, deathEffectID);
 
     //components that we need from player
     auto playerModel = player.FirstChildByName("PlayerModel");

src/Game/Systems/PlayerMovementSystem.cpp

@@ -328,10 +328,8 @@ bool PlayerMovementSystem::OnDoubleJump(Events::DoubleJump & e)
 void PlayerMovementSystem::spawnHexagon(EntityWrapper target)
 {
     //put a hexagon at the entitys... feet?
-    auto hexagonEffect = ResourceManager::Load<EntityFile>("Schema/Entities/DoubleJumpHexagon.xml");
+    auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/DoubleJumpHexagon.xml");
-    EntityFileParser parser(hexagonEffect);
+    EntityWrapper hexagonEW = entityFile->MergeInto(m_World);
-    EntityID hexagonEffectID = parser.MergeEntities(m_World);
-    EntityWrapper hexagonEW = EntityWrapper(m_World, hexagonEffectID);
     hexagonEW["Transform"]["Position"] = (glm::vec3)target["Transform"]["Position"];
 }
 
@@ -342,10 +340,8 @@ bool PlayerMovementSystem::OnDashAbility(Events::DashAbility & e)
         return false;
     }
 
-    auto dashEffectResource = ResourceManager::Load<EntityFile>("Schema/Entities/DashEffect.xml");
+    auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/DashEffect.xml");
-    EntityFileParser parser(dashEffectResource);
+    EntityWrapper dashEffect = entityFile->MergeInto(m_World);
-    EntityID dashEffectID = parser.MergeEntities(m_World);
-    EntityWrapper dashEffect(m_World, dashEffectID);
     auto playerModel = player.FirstChildByName("PlayerModel");
     auto playerEntityModel = playerModel["Model"];
     auto playerEntityAnimation = playerModel["Animation"];

src/Game/Systems/SpawnerSystem.cpp

@@ -17,15 +17,17 @@ EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /
 
     // Load the entity file and parse it
     const std::string& entityFilePath = spawner["Spawner"]["EntityFile"];
-    auto entityFile = ResourceManager::Load<EntityFile>(entityFilePath);
+    EntityWrapper spawnedEntity;
-    if (entityFile == nullptr) {
+    try {
+        auto entityFile = ResourceManager::Load<EntityFile>(entityFilePath);
+        spawnedEntity = entityFile->MergeInto(world);
+        world->SetParent(spawnedEntity.ID, parent.ID);
+    } catch (const Resource::FailedLoadingException& e) {
         return EntityWrapper::Invalid;
     }
-    EntityFileParser parser(entityFile);
-    EntityWrapper spawnedEntity(world, parser.MergeEntities(world, parent.ID));
 
-    //If the spawned entity is collideable, then we must not spawn it where it collides with something that
+    // If the spawned entity is collidable, then we must not spawn it where it collides with something that
-    //has a dontCollideComponent attached.
+    // has a dontCollideComponent attached.
     bool spawnOnCollidable = dontCollideComponent.empty() || !spawnedEntity.HasComponent("Collidable");
     if (!spawnOnCollidable) {
         boost::optional<EntityAABB> optBox = Collision::EntityAbsoluteAABB(spawnedEntity);

src/Tests/CapturePointTest.cpp

@@ -7,7 +7,7 @@ using boost::unit_test_framework::test_case;
 
 #include "Collision/TriggerSystem.h"
 #include "Collision/CollisionSystem.h"
-#include "Core/EntityFileWriter.h"
+#include "Core/EntityXMLFileWriter.h"
 #include "Game/Systems/CapturePointSystem.h"
 
 BOOST_AUTO_TEST_SUITE(CapturePointTestSuite)
@@ -82,7 +82,7 @@ bool CapturePointTest::CapturePoint_Game_Loop_OneHundredTimes() {
 CapturePointTest::CapturePointTest(int runTestNumber)
 {
     ResourceManager::RegisterType<ConfigFile>("ConfigFile");
-    ResourceManager::RegisterType<EntityFile>("EntityFile");
+    ResourceManager::RegisterType<EntityXMLFile>("EntityFile");
 
     m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
     LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
@@ -99,10 +99,10 @@ CapturePointTest::CapturePointTest(int runTestNumber)
     m_SystemPipeline->AddSystem<CapturePointSystem>(1);
 
     //must register components (Components.xsd), else you cant create entities. Easiest done by loading a test xsd file
-    auto file = ResourceManager::Load<EntityFile>("Schema/Entities/TeamTest.xml");
+    auto file = ResourceManager::Load<EntityXMLFile>("Schema/Entities/TeamTest.xml");
-    EntityFilePreprocessor fpp(file);
+    EntityXMLFilePreprocessor fpp(file);
     fpp.RegisterComponents(m_World);
-    EntityFileParser fp(file);
+    EntityXMLFileParser fp(file);
     fp.MergeEntities(m_World);
 
     EntityID playerID = m_World->CreateEntity();

src/Tests/CapturePointTest.h

@@ -9,12 +9,12 @@
 #include "Input/KeyboardInputHandler.h"
 #include "Input/MouseInputHandler.h"
 #include "Core/EKeyDown.h"
-#include "Core/EntityFile.h"
+#include "Core/EntityXMLFile.h"
 #include "Core/SystemPipeline.h"
 
-#include "Core/EntityFilePreprocessor.h"
+#include "Core/EntityXMLFilePreprocessor.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityXMLFileParser.h"
-#include "Core/EntityFileWriter.h"
+#include "Core/EntityXMLFileWriter.h"
 
 #include "Engine/Collision/ETrigger.h"
 

src/Tests/HealthSystemTest.cpp

@@ -30,7 +30,7 @@ BOOST_AUTO_TEST_SUITE_END()
 GameHealthSystemTest::GameHealthSystemTest()
 {
     ResourceManager::RegisterType<ConfigFile>("ConfigFile");
-    ResourceManager::RegisterType<EntityFile>("EntityFile");
+    ResourceManager::RegisterType<EntityXMLFile>("EntityFile");
 
     m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
     LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
@@ -41,10 +41,10 @@ GameHealthSystemTest::GameHealthSystemTest()
     // Create a world
     m_World = new World();
 
-    auto file = ResourceManager::Load<EntityFile>("Schema/Entities/TeamTest.xml");
+    auto file = ResourceManager::Load<EntityXMLFile>("Schema/Entities/TeamTest.xml");
-    EntityFilePreprocessor fpp(file);
+    EntityXMLFilePreprocessor fpp(file);
     fpp.RegisterComponents(m_World);
-    EntityFileParser fp(file);
+    EntityXMLFileParser fp(file);
     fp.MergeEntities(m_World);
 
     // Create system pipeline

src/Tests/HealthSystemTest.h

@@ -11,7 +11,7 @@
 #include "Input/KeyboardInputHandler.h"
 #include "Input/MouseInputHandler.h"
 #include "Core/EKeyDown.h"
-#include "Core/EntityFile.h"
+#include "Core/EntityXMLFile.h"
 #include "Core/SystemPipeline.h"
 #include "Editor/EditorSystem.h"
 

src/Tests/PickupSpawnTest.cpp

@@ -30,7 +30,7 @@ BOOST_AUTO_TEST_SUITE_END()
 PickupSpawnTest::PickupSpawnTest(int runTestNumber)
 {
     ResourceManager::RegisterType<ConfigFile>("ConfigFile");
-    ResourceManager::RegisterType<EntityFile>("EntityFile");
+    ResourceManager::RegisterType<EntityXMLFile>("EntityFile");
 
     m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
     LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
@@ -44,10 +44,10 @@ PickupSpawnTest::PickupSpawnTest(int runTestNumber)
     m_SystemPipeline->AddSystem<PickupSpawnSystem>(1);
 
     //must register components (Components.xsd), else you cant create entities. Easiest done by loading a test xsd file
-    auto file = ResourceManager::Load<EntityFile>("Schema/Entities/HealthPickup.xml");
+    auto file = ResourceManager::Load<EntityXMLFile>("Schema/Entities/HealthPickup.xml");
-    EntityFilePreprocessor fpp(file);
+    EntityXMLFilePreprocessor fpp(file);
     fpp.RegisterComponents(m_World);
-    EntityFileParser fp(file);
+    EntityXMLFileParser fp(file);
     //connect the healthpickup to the world
     m_HealthPickupID = fp.MergeEntities(m_World);
 

src/Tests/PickupSpawnTest.h

@@ -9,12 +9,12 @@
 #include "Input/KeyboardInputHandler.h"
 #include "Input/MouseInputHandler.h"
 #include "Core/EKeyDown.h"
-#include "Core/EntityFile.h"
+#include "Core/EntityXMLFile.h"
 #include "Core/SystemPipeline.h"
 
-#include "Core/EntityFilePreprocessor.h"
+#include "Core/EntityXMLFilePreprocessor.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityXMLFileParser.h"
-#include "Core/EntityFileWriter.h"
+#include "Core/EntityXMLFileWriter.h"
 
 #include "Engine/Collision/ETrigger.h"
 
@@ -29,7 +29,7 @@
 //#include <tuple>
 #include "Collision/TriggerSystem.h"
 #include "Collision/CollisionSystem.h"
-#include "Core/EntityFileWriter.h"
+#include "Core/EntityXMLFileWriter.h"
 #include "Game/Systems/HealthSystem.h"
 #include "Game/Systems/PickupSpawnSystem.h"