Add normal map support

.gitignore

@@ -4,11 +4,3 @@ bin/
 lib/
 # Because apparently nobody has any self control
 *.orig
-
-*.suo
-*.sdf
-tools/MayaExporter/MayaExporter/x64/Debug/
-tools/MayaExporter/x64/Debug/
-
-tools/MayaExporter/MayaExporter/Debug/
-tools/MayaExporter/MayaExporter/GeneratedFiles/

CMakeLists.txt

@@ -14,9 +14,6 @@ endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
-elseif(MSVC)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
-	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
 #set(BUILD_SHARED_LIBS FALSE)
@@ -37,12 +34,6 @@ foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
     set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY})
 endforeach(OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES)
 
-# DEBUG definition
-set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS
-	$<$<CONFIG:Debug>:DEBUG>
-	$<$<CONFIG:RelWithDebInfo>:DEBUG>
-)
-
 include(cotire)
 add_subdirectory(src/Engine)
 add_subdirectory(src/Game)

include/Engine/Collision/CollidableOctreeSystem.h

@@ -4,14 +4,13 @@
 #include "../Core/System.h"
 #include "../Core/Octree.h"
 #include "Collision.h"
-#include "EntityAABB.h"
 
 class CollidableOctreeSystem : public ImpureSystem, public PureSystem
 {
 public:
-    CollidableOctreeSystem(World* world, EventBroker* eventBroker, Octree<EntityAABB>* octree, const std::string& componentType)
+    CollidableOctreeSystem(World* world, EventBroker* eventBroker, Octree<AABB>* octree)
         : System(world, eventBroker)
-        , PureSystem(componentType)
+        , PureSystem("Collidable")
         , m_Octree(octree)
     { }
 
@@ -19,7 +18,7 @@ public:
     virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
-    Octree<EntityAABB>* m_Octree;
+    Octree<AABB>* m_Octree;
 };
 
 #endif

include/Engine/Collision/Collision.h

@@ -10,12 +10,10 @@
 
 #include "../Core/Ray.h"
 #include "../Core/AABB.h"
-#include "Rendering/RawModelCustom.h"
-//#include "Rendering/RawModelAssimp.h"
+#include "../Rendering/RawModel.h"
 #include "../Core/Transform.h"
 #include "../Core/Entity.h"
 #include "../Core/EntityWrapper.h"
-#include "EntityAABB.h"
 
 class World;
 struct ComponentWrapper;
@@ -59,9 +57,10 @@ bool AABBVsAABB(const AABB& a, const AABB& b);
 //Return true if the boxes are intersecting.
 //Also outputs the minimum translation that box [a] would need in order to resolve collision.
 bool AABBVsAABB(const AABB& a, const AABB& b, glm::vec3& minimumTranslation);
+bool IsSameBoxProbably(const AABB& first, const AABB& second, const float epsilon = 0.0001f);
 
 // Calculates an absolute AABB from an entity AABB component
-boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity);
+boost::optional<AABB> EntityAbsoluteAABB(EntityWrapper& entity);
 
 }
 

include/Engine/Collision/CollisionSystem.h

@@ -7,23 +7,30 @@
 #include "../Common.h"
 #include "../Core/System.h"
 #include "../Core/EventBroker.h"
+#include "../Core/EKeyUp.h"
 #include "../Core/Octree.h"
-#include "EntityAABB.h"
 
 class CollisionSystem : public PureSystem
 {
 public:
-    CollisionSystem(World* world, EventBroker* eventBroker, Octree<EntityAABB>* octree)
+    CollisionSystem(World* world, EventBroker* eventBroker, Octree<AABB>* octree)
         : System(world, eventBroker)
         , PureSystem("Collidable")
         , m_Octree(octree)
-    { }
+        , zPress(false)
+    {
+        //TODO: Debug stuff, remove later.
+        EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &CollisionSystem::OnKeyUp);
+    }
 
     virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
-    Octree<EntityAABB>* m_Octree;
-    std::vector<EntityAABB> m_OctreeResult;
+    Octree<AABB>* m_Octree;
+    bool zPress;
+
+    EventRelay<CollisionSystem, Events::KeyUp> m_EKeyUp;
+    bool OnKeyUp(const Events::KeyUp &event);
 };
 
 #endif

include/Engine/Collision/ETrigger.h

@@ -2,7 +2,7 @@
 #define Events_TriggerEnter_h__
 
 #include "../Core/EventBroker.h"
-#include "../Core/EntityWrapper.h"
+#include "../Core/Entity.h"
 
 namespace Events
 {
@@ -11,27 +11,27 @@ namespace Events
 struct TriggerTouch : Event
 {
     /** The id of the entity that touches the trigger. */
-    EntityWrapper Entity;
+    EntityID Entity;
     /** The id of the trigger entity. */
-    EntityWrapper Trigger;
+    EntityID Trigger;
 };
 
 /** Thrown once, when an entity has completely left a trigger. */
 struct TriggerLeave : Event
 {
     /** The id of the entity that left the trigger. */
-    EntityWrapper Entity;
+    EntityID Entity;
     /** The id of the trigger entity. */
-    EntityWrapper Trigger;
+    EntityID Trigger;
 };
 
 /** Thrown once, when an entity is completely contained inside a trigger. */
 struct TriggerEnter : Event
 {
     /** The id of the entity that entered the trigger. */
-    EntityWrapper Entity;
+    EntityID Entity;
     /** The id of the trigger entity. */
-    EntityWrapper Trigger;
+    EntityID Trigger;
 };
 
 }

include/Engine/Collision/EntityAABB.h

@@ -1,22 +0,0 @@
-#ifndef EntityAABB_h__
-#define EntityAABB_h__
-
-#include "../Core/AABB.h"
-#include "../Core/EntityWrapper.h"
-
-struct EntityAABB : AABB
-{
-    EntityAABB() = default;
-
-    EntityAABB(const glm::vec3& minPos, const glm::vec3& maxPos)
-        : AABB(minPos, maxPos)
-    { }
-
-    EntityAABB(const AABB& aabb)
-        : AABB(aabb)
-    { }
-
-    EntityWrapper Entity;
-};
-
-#endif

include/Engine/Collision/TriggerSystem.h

@@ -8,14 +8,13 @@
 #include "../Core/EventBroker.h"
 #include "../Core/Octree.h"
 #include "ETrigger.h"
-#include "EntityAABB.h"
 
 class AABB;
 
 class TriggerSystem : public PureSystem
 {
 public:
-    TriggerSystem(World* world, EventBroker* eventBroker, Octree<EntityAABB>* octree)
+    TriggerSystem(World* world, EventBroker* eventBroker, Octree<AABB>* octree)
         : System(world, eventBroker)
         , PureSystem("Trigger")
         , m_Octree(octree)
@@ -28,10 +27,9 @@ public:
     virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
-    Octree<EntityAABB>* m_Octree;
-    std::vector<EntityAABB> m_OctreeOut;
-    std::unordered_map<EntityWrapper, std::unordered_set<EntityWrapper>> m_EntitiesTouchingTrigger;
-    std::unordered_map<EntityWrapper, std::unordered_set<EntityWrapper>> m_EntitiesCompletelyInTrigger;
+    Octree<AABB>* m_Octree;
+    std::unordered_map<EntityID, std::unordered_set<EntityID>> m_EntitiesTouchingTrigger;
+    std::unordered_map<EntityID, std::unordered_set<EntityID>> m_EntitiesCompletelyInTrigger;
 
     //TODO: Only exists for debug purposes, remove later.
     EventRelay<TriggerSystem, Events::TriggerEnter> m_EEnter;
@@ -42,13 +40,13 @@ private:
     bool OnLeave(const Events::TriggerLeave &event);
 
     //True if leave event was thrown.
-    bool throwLeaveIfWasInTrigger(std::unordered_set<EntityWrapper>& triggerSet, EntityWrapper colliderENtity, EntityWrapper triggerEntity);
+    bool throwLeaveIfWasInTrigger(std::unordered_set<EntityID>& triggerSet, EntityID pId, EntityID tId);
     template<typename Event>
-    void publish(EntityWrapper collider, EntityWrapper trigger)
+    void publish(EntityID pId, EntityID tId)
     {
         Event e;
-        e.Trigger = trigger;
-        e.Entity = collider;
+        e.Trigger = tId;
+        e.Entity = pId;
         m_EventBroker->Publish(e);
     }
 };

include/Engine/Common.h

@@ -5,7 +5,6 @@
 #include <map>
 #include <unordered_map>
 #include <algorithm>
-#include <array>
 
 #include "Core/Util/Logging.h"
 #include "Core/Util/IfDebug.h"

include/Engine/Core/AABB.h

@@ -9,6 +9,7 @@ public:
     AABB() = default;
     //No checks are made. Values in minPos must be less than values in maxPos, i.e. min.x < max.x, etc.
     AABB(const glm::vec3& minPos, const glm::vec3& maxPos);
+    AABB(const glm::vec4& minPos, const glm::vec4& maxPos);
     //No checks are made. Size must consist of non-negative numbers.
     static AABB FromOriginSize(const glm::vec3& origin, const glm::vec3& size);
     virtual ~AABB();

include/Engine/Core/ComponentWrapper.h

@@ -81,7 +81,7 @@ class ComponentWrapperFactory
 {
 public:
     ComponentWrapperFactory() = default;
-    ComponentWrapperFactory(std::string componentTypeName, unsigned int allocation = 0)
+    ComponentWrapperFactory(std::string componentTypeName, std::size_t allocation = 0)
     {
         m_ComponentInfo.Name = componentTypeName;
         m_ComponentInfo.Meta->Allocation = allocation;

include/Engine/Core/EComponentDeleted.h

@@ -1,21 +0,0 @@
-#ifndef EComponentDeleted_h__
-#define EComponentDeleted_h__
-
-#include "../Common.h"
-#include "Event.h"
-#include "Entity.h"
-
-namespace Events
-{
-
-struct ComponentDeleted : Event
-{
-    EntityID Entity;
-    std::string ComponentType;
-    // True if the component was deleted as a result of the entity it was attached to being deleted
-    bool Cascaded;
-};
-
-}
-
-#endif

include/Engine/Core/EEntityDeleted.h

@@ -1,19 +0,0 @@
-#ifndef EEntityDeleted_h__
-#define EEntityDeleted_h__
-
-#include "Event.h"
-#include "Entity.h"
-
-namespace Events
-{
-
-struct EntityDeleted : Event
-{
-    EntityID DeletedEntity;
-    // True if the entity deletion was triggered because the entity's parent was deleted before it
-    bool Cascaded;
-};
-
-}
-
-#endif

include/Engine/Core/EPlayerDamage.h

@@ -2,15 +2,15 @@
 #define EPlayerDamage_h__
 
 #include "EventBroker.h"
-#include "../Core/EntityWrapper.h"
+#include "../Core/Entity.h"
 
 namespace Events
 {
 
 struct PlayerDamage : Event
 {
-    EntityWrapper Player;
-    double Damage;
+    double DamageAmount;
+    EntityID PlayerDamagedID;
 };
 
 }

include/Engine/Core/EPlayerSpawned.h

@@ -1,20 +0,0 @@
-#ifndef EPlayerSpawned_h__
-#define EPlayerSpawned_h__
-
-#include "Core/Event.h"
-#include "Core/EntityWrapper.h"
-
-namespace Events
-{
-
-struct PlayerSpawned : Event
-{
-    int PlayerID;
-    EntityWrapper Player;
-    EntityWrapper Spawner;
-    std::string PlayerName;
-};
-
-}
-
-#endif

include/Engine/Core/EShoot.h

@@ -2,14 +2,16 @@
 #define EShoot_h__
 
 #include "EventBroker.h"
-#include "../Core/EntityWrapper.h"
+#include "../Core/Entity.h"
+#include "Engine/GLM.h"
 
 namespace Events
 {
 
 struct Shoot : Event
 {
-    EntityWrapper Player;
+    //ID for who made the shot
+    EntityID shooter;
 };
 
 }

include/Engine/Core/EntityFile.h

@@ -143,7 +143,7 @@ private:
     ~EntityFile();
 
 public:
-    static unsigned int GetTypeStride(std::string typeName);
+    static std::size_t 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);
 

include/Engine/Core/EntityWrapper.h

@@ -23,21 +23,15 @@ struct EntityWrapper
 
     static const EntityWrapper Invalid;
 
-    const std::string Name();
-    bool HasComponent(const std::string& componentType);
+    bool HasComponent(const std::string& componentName);
     EntityWrapper Parent();
-    EntityWrapper FirstChildByName(const std::string& name);
-    EntityWrapper FirstParentWithComponent(const std::string& componentType);
-    bool IsChildOf(EntityWrapper potentialParent);
     bool Valid();
 
     ComponentWrapper operator[](const char* componentName);
     bool operator==(const EntityWrapper& e) const;
     bool operator!=(const EntityWrapper& e) const;
     explicit operator EntityID() const;
-
-private:
-    EntityWrapper firstChildByNameRecursive(const std::string& name, EntityID parent);
+    operator bool();
 };
 
 namespace std

include/Engine/Core/Octree.h

@@ -111,7 +111,7 @@ struct Child
     std::vector<ContainedObject>& m_StaticObjectsRef;
     std::vector<ContainedObject>& m_DynamicObjectsRef;
 
-    bool hasChildren() const;
+    inline bool hasChildren() const;
     int childIndexContainingPoint(const glm::vec3& point) const;
     std::vector<int> childIndicesContainingBox(const AABB& box) const;
 };

include/Engine/Core/ResourceManager.h

@@ -32,10 +32,10 @@ public:
     };
     struct FailedLoadingException : public std::exception
     {
-        FailedLoadingException(char const* const _Message)
-            : std::exception(_Message)
-        { }
-        FailedLoadingException() :std::exception("Resource failed to load.") { };
+        virtual const char* what() const throw()
+        {
+            return "Resource is failed to load.";
+        }
     };
 
 	// Pretend that this is a pure virtual function that you have to implement

include/Engine/Core/Transform.h

@@ -3,20 +3,13 @@
 
 #include "../GLM.h"
 #include "World.h"
-#include "EntityWrapper.h"
 
 namespace Transform
 {
 
-glm::mat4 AbsoluteTransformation(EntityWrapper entity);
-glm::vec3 AbsolutePosition(EntityWrapper entity);
 glm::vec3 AbsolutePosition(World* world, EntityID entity);
-glm::vec3 AbsoluteOrientationEuler(EntityWrapper entity);
-glm::quat AbsoluteOrientation(EntityWrapper entity);
 glm::quat AbsoluteOrientation(World* world, EntityID entity);
-glm::vec3 AbsoluteScale(EntityWrapper entity);
 glm::vec3 AbsoluteScale(World* world, EntityID entity);
-glm::mat4 ModelMatrix(EntityWrapper entity);
 glm::mat4 ModelMatrix(EntityID entity, World* world);
 
 }

include/Engine/Core/Util/FileWatcher.h

@@ -42,7 +42,7 @@ enum class FileWatcher::FileEventFlags
 };
 
 inline FileWatcher::FileEventFlags operator|(FileWatcher::FileEventFlags a, FileWatcher::FileEventFlags b) { return static_cast<FileWatcher::FileEventFlags>(static_cast<int>(a) | static_cast<int>(b)); }
-inline bool operator&(FileWatcher::FileEventFlags a, FileWatcher::FileEventFlags b) { return (static_cast<int>(a) & static_cast<int>(b)) != 0; }
+inline bool operator&(FileWatcher::FileEventFlags a, FileWatcher::FileEventFlags b) { return static_cast<int>(a)& static_cast<int>(b); }
 
 class FileWatcher::Worker
 {
@@ -54,7 +54,7 @@ public:
 private:
 	struct FileInfo
 	{
-		std::size_t Size;
+		int Size;
 		std::time_t Timestamp;
 	};
 

include/Engine/Core/Util/Logging.h

@@ -29,9 +29,41 @@ enum _LOG_LEVEL
 
 extern _LOG_LEVEL LOG_LEVEL;
 
-extern const char* _LOG_LEVEL_PREFIX[];
+const static char* _LOG_LEVEL_PREFIX[] =
+{
+	"EE: ",
+	"",
+	"WW: ",
+	"DD: "
+};
 
-extern void _LOG(_LOG_LEVEL logLevel, const char* file, const char* func, unsigned int line, const char* format, ...);
+static void _LOG(_LOG_LEVEL logLevel, const char* file, const char* func, unsigned int line, const char* format, ...)
+{
+	if (logLevel > LOG_LEVEL) {
+		return;
+	}
+
+	char* message = nullptr;
+	va_list args;
+
+	va_start(args, format);
+	size_t size = vsnprintf(message, 0, format, args) + 1;
+	va_end(args);
+
+	va_start(args, format);
+	message = new char[size];
+	vsnprintf(message, size, format, args);
+	va_end(args);
+
+	if (logLevel == LOG_LEVEL_ERROR) {
+		std::cerr << file << ":" << line << " " << func << std::endl;
+		std::cerr << _LOG_LEVEL_PREFIX[logLevel] << message << std::endl;
+	} else {
+		std::cout << _LOG_LEVEL_PREFIX[logLevel] << message << std::endl;
+	}
+
+	delete[] message;
+}
 
 #define LOG(logLevel, format, ...) \
 	_LOG(logLevel, __BASE_FILE__, __func__, __LINE__, format, ##__VA_ARGS__)
@@ -45,11 +77,7 @@ extern void _LOG(_LOG_LEVEL logLevel, const char* file, const char* func, unsign
 #define LOG_INFO(format, ...) \
 	LOG(LOG_LEVEL_INFO, format, ##__VA_ARGS__)
 
-#ifdef DEBUG
 #define LOG_DEBUG(format, ...) \
 	LOG(LOG_LEVEL_DEBUG, format, ##__VA_ARGS__)
-#else
-#define LOG_DEBUG(format, ...) 
-#endif
 
 #endif // Logging_h__

include/Engine/Core/World.h

@@ -5,15 +5,11 @@
 #include "Entity.h"
 #include "ObjectPool.h"
 #include "ComponentPool.h"
-#include "EventBroker.h"
 
 class World
 {
 public:
     World() = default;
-    World(EventBroker* eventBroker) 
-        : m_EventBroker(eventBroker)
-    { }
     ~World();
 
     // Create empty entity
@@ -50,7 +46,6 @@ public:
     std::string GetName(EntityID entity) const;
 
 private:
-    EventBroker* m_EventBroker = nullptr;
     EntityID m_CurrentEntityID = 0;
 
     std::unordered_map<EntityID, EntityID> m_EntityParents;
@@ -60,7 +55,6 @@ private:
     std::unordered_map<EntityID, std::string> m_EntityNames;
 
     EntityID generateEntityID();
-    void deleteEntityRecursive(EntityID entity, bool cascaded = false);
 };
 
 #endif

include/Engine/Editor/EditorCameraInputController.h

@@ -1,115 +0,0 @@
-#ifndef EditorCameraInputController_h__
-#define EditorCameraInputController_h__
-
-#include <imgui/imgui.h>
-#include "../Input/FirstPersonInputController.h"
-#include "../Core/EMousePress.h"
-#include "../Core/EMouseRelease.h"
-#include "../Core/EMouseScroll.h"
-#include "../Core/ConfigFile.h"
-
-template <typename EventContext>
-class EditorCameraInputController : public FirstPersonInputController<EventContext>
-{
-public:
-    EditorCameraInputController(EventBroker* eventBroker, unsigned int playerID)
-        : FirstPersonInputController(eventBroker, playerID)
-    {
-        EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &EditorCameraInputController::OnMousePress);
-        EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &EditorCameraInputController::OnMouseRelease);
-        EVENT_SUBSCRIBE_MEMBER(m_EMouseScroll, &EditorCameraInputController::OnMouseScroll);
-
-        m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
-        m_SpeedMultiplier = m_Config->Get<float>("Editor.CameraSpeed", 3.f);
-    }
-    
-    virtual const glm::vec3 Movement() const override { return m_Movement * static_cast<float>(m_SpeedMultiplier); }
-
-    void Enable() { m_Enabled = true; }
-    void Disable() { m_Enabled = false; }
-
-    virtual bool OnCommand(const Events::InputCommand& e) override
-    {
-        if (glm::abs(e.Value) > 0 && !m_MouseLocked) {
-            return false;
-        }
-
-        ImGuiIO& io = ImGui::GetIO();
-        if (glm::abs(e.Value) > 0 && (io.WantCaptureKeyboard || io.WantCaptureMouse)) {
-            return false;
-        }
-
-        if (e.Command == "Jump") {
-            if (e.Value > 0) {
-                m_Movement.y = glm::max(e.Value, 1.f);
-            } else {
-                m_Movement.y = 0.f;
-            }
-        }
-
-        if (e.Command == "Crouch") {
-            if (e.Value > 0) {
-                m_Movement.y = glm::min(-e.Value, -1.f);
-            } else {
-                m_Movement.y = 0.f;
-            }
-        }
-
-        if (e.Command == "Sprint") {
-            if (e.Value > 0) {
-                m_SpeedMultiplier *= 2.f;
-            } else {
-                m_SpeedMultiplier /= 2.f;
-            }
-        }
-
-        return FirstPersonInputController::OnCommand(e);
-    }
-
-protected:
-    ConfigFile* m_Config;
-    bool m_Enabled = false;
-    double m_SpeedMultiplier = 1.f;
-
-    EventRelay<EventContext, Events::MousePress> m_EMousePress;
-    bool OnMousePress(const Events::MousePress& e)
-    {
-        if (!m_Enabled) {
-            return false;
-        }
-
-        if (e.Button == GLFW_MOUSE_BUTTON_2) {
-            ImGuiIO& io = ImGui::GetIO();
-            if (!io.WantCaptureMouse) {
-                LockMouse();
-            }
-        }
-        return true;
-    }
-    EventRelay<EventContext, Events::MouseRelease> m_EMouseRelease;
-    bool OnMouseRelease(const Events::MouseRelease& e)
-    {
-        if (!m_Enabled) {
-            return false;
-        }
-
-        if (e.Button == GLFW_MOUSE_BUTTON_2) {
-            UnlockMouse();
-        }
-        return true;
-    }
-    EventRelay<EventContext, Events::MouseScroll> m_EMouseScroll;
-    bool OnMouseScroll(const Events::MouseScroll& e)
-    {
-        if (!m_Enabled) {
-            return false;
-        }
-
-        m_SpeedMultiplier += e.DeltaY * (0.1 * m_SpeedMultiplier);
-        m_Config->Set("Editor.CameraSpeed", m_SpeedMultiplier);
-        m_Config->SaveToDisk();
-        return true;
-    }
-};
-
-#endif

include/Engine/Editor/EditorGUI.h

@@ -7,7 +7,6 @@
 #include <nativefiledialog/nfd.h>
 #include <boost/filesystem.hpp>
 #include <boost/any.hpp>
-#include <boost/algorithm/string/replace.hpp>
 #include "../Common.h"
 #include "../GLM.h"
 #include <glm/gtx/common.hpp>
@@ -19,8 +18,6 @@
 #include "../Core/ResourceManager.h"
 #include "../Core/EPause.h"
 #include "../Core/EKeyDown.h"
-#include "../Core/ELockMouse.h"
-#include "../Core/EFileDropped.h"
 #include "../Rendering/Texture.h"
 
 class EditorGUI
@@ -35,12 +32,6 @@ public:
         Scale
     };
 
-    enum class WidgetSpace
-    {
-        Global,
-        Local
-    };
-
     void Draw();
 
     void SelectEntity(EntityWrapper entity);
@@ -82,9 +73,6 @@ public:
     // Called when the user selects a widget mode.
     typedef std::function<void(WidgetMode)> OnWidgetMode_t;
     void SetWidgetModeCallback(OnWidgetMode_t f) { m_OnWidgetMode = f; }
-    // Called when the user selects a widget space.
-    typedef std::function<void(WidgetSpace)> OnWidgetSpace_t;
-    void SetWidgetSpaceCallback(OnWidgetSpace_t f) { m_OnWidgetSpace = f; }
 
 private:
     World* m_World;
@@ -105,12 +93,8 @@ private:
     EntityWrapper m_CurrentlyDragging = EntityWrapper::Invalid;
     std::string m_LastErrorMessage;
     WidgetMode m_CurrentWidgetMode = WidgetMode::Translate;
-    WidgetSpace m_CurrentWidgetSpace = WidgetSpace::Global;
     std::set<std::string> m_ModalsToOpen;
     std::map<std::string, boost::any> m_ModalData;
-    std::string m_DroppedFile = "";
-    bool m_Paused = false;
-    bool m_MouseLocked = false;
 
     // Callbacks
     OnEntitySelectedCallback_t m_OnEntitySelected = nullptr;
@@ -123,21 +107,10 @@ private:
     OnComponentAttach_t m_OnComponentAttach = nullptr;
     OnComponentDelete_t m_OnComponentDelete = nullptr;
     OnWidgetMode_t m_OnWidgetMode = nullptr;
-    OnWidgetSpace_t m_OnWidgetSpace = nullptr;
 
     // Events
     EventRelay<EditorGUI, Events::KeyDown> m_EKeyDown;
     bool OnKeyDown(const Events::KeyDown& e);
-    EventRelay<EditorGUI, Events::FileDropped> m_EFileDropped;
-    bool OnFileDropped(const Events::FileDropped& e);
-    EventRelay<EditorGUI, Events::Pause> m_EPause;
-    bool OnPause(const Events::Pause& e);
-    EventRelay<EditorGUI, Events::Resume> m_EResume;
-    bool OnResume(const Events::Resume& e);
-    EventRelay<EditorGUI, Events::LockMouse> m_ELockMouse;
-    bool OnLockMouse(const Events::LockMouse& e);
-    EventRelay<EditorGUI, Events::UnlockMouse> m_EUnlockMouse;
-    bool OnUnlockMouse(const Events::UnlockMouse& e);
 
     // Utility functions
     boost::filesystem::path fileOpenDialog();
@@ -145,9 +118,6 @@ private:
     const std::string formatEntityName(EntityWrapper entity);
     GLuint tryLoadTexture(std::string filePath);
     void openModal(const std::string& modal);
-    void setWidgetMode(WidgetMode mode);
-    void toggleWidgetSpace();
-    static bool compareCharArray(const char* c1, const char* c2);
 
     // Entity file handling methods
     void entityImport(World* world);

include/Engine/Editor/EditorSystem.h

@@ -1,6 +1,7 @@
 #include "../Core/System.h"
 #include "../Rendering/IRenderer.h"
 #include "../Rendering/Camera.h"
+#include "../Rendering/DebugCameraInputController.h"
 #include "../Rendering/ESetCamera.h"
 #include "../Core/World.h"
 #include "../Core/SystemPipeline.h"
@@ -9,10 +10,8 @@
 #include "../Core/EntityFileParser.h"
 #include "../Core/EntityFileWriter.h"
 #include "../Core/EMousePress.h"
-#include "../Input/EInputCommand.h"
 #include "EditorGUI.h"
 #include "EditorStats.h"
-#include "EditorCameraInputController.h"
 
 class EditorSystem : public ImpureSystem
 {
@@ -22,26 +21,19 @@ public:
 
     void Update(double dt);
 
-    void Enable();
-    void Disable();
-
 private:
     IRenderer* m_Renderer;
     RenderFrame* m_RenderFrame;
     World* m_EditorWorld;
     SystemPipeline* m_EditorWorldSystemPipeline;
-    //Camera* m_EditorCamera;
-    EntityWrapper m_EditorCamera = EntityWrapper::Invalid;
-    EntityWrapper m_ActualCamera = EntityWrapper::Invalid;
-    EditorCameraInputController<EditorSystem>* m_EditorCameraInputController;
+    Camera* m_EditorCamera;
+    EntityWrapper m_Camera = EntityWrapper::Invalid;
+    DebugCameraInputController<EditorSystem>* m_DebugCameraInputController;
     EditorGUI* m_EditorGUI;
     EditorStats* m_EditorStats;
 
     // State
-    double m_LastTime = 0.f;
-    bool m_Enabled = true;
     EditorGUI::WidgetMode m_WidgetMode = EditorGUI::WidgetMode::Translate;
-    EditorGUI::WidgetSpace m_WidgetSpace = EditorGUI::WidgetSpace::Global;
     EntityWrapper m_Widget = EntityWrapper::Invalid;
     EntityWrapper m_CurrentSelection = EntityWrapper::Invalid;
 
@@ -58,15 +50,10 @@ private:
     void OnEntityChangeName(EntityWrapper entity, const std::string& name);
     void OnComponentAttach(EntityWrapper entity, const std::string& componentType);
     void OnComponentDelete(EntityWrapper entity, const std::string& componentType);
-    void OnWidgetSpace(EditorGUI::WidgetSpace widgetSpace);
 
     // Events
     EventRelay<EditorSystem, Events::MousePress> m_EMousePress;
     bool OnMousePress(const Events::MousePress& e);
     EventRelay<EditorSystem, Events::WidgetDelta> m_EWidgetDelta;
     bool OnWidgetDelta(const Events::WidgetDelta& e);
-    EventRelay<EditorSystem, Events::InputCommand> m_EInputCommand;
-    bool OnInputCommand(const Events::InputCommand& e);
-    EventRelay<EditorSystem, Events::SetCamera> m_ESetCamera;
-    bool OnSetCamera(const Events::SetCamera& e);
 };

include/Engine/Input/EInputCommand.h

@@ -2,7 +2,6 @@
 #define Events_InputCommand_h__
 
 #include "Core/EventBroker.h"
-#include "Core/EntityWrapper.h"
 
 namespace Events
 {
@@ -10,8 +9,7 @@ namespace Events
 struct InputCommand : Event
 {
 	/** Numerical ID of the player. */
-	int PlayerID;
-    EntityWrapper Player;
+	unsigned int PlayerID;
 	/** The command that was sent. */
 	std::string Command;
 	/** The value of the command. */

include/Engine/Input/FirstPersonInputController.h

@@ -9,124 +9,62 @@ template <typename EventContext>
 class FirstPersonInputController : public InputController<EventContext>
 {
 public:
-    FirstPersonInputController(EventBroker* eventBroker, int playerID);
-
-    virtual const glm::vec3 Movement() const { return m_Movement; }
-    virtual const glm::vec3 Rotation() const { return m_Rotation; }
-    virtual bool Jumping() const { return m_Jumping; }
-    virtual bool Crouching() const { return m_Crouching; }
-    virtual bool DoubleJumping() const { return m_DoubleJumping; }
-    virtual void SetDoubleJumping(bool isDoubleJumping) {
-        m_DoubleJumping = isDoubleJumping;
+    FirstPersonInputController(EventBroker* eventBroker, unsigned int playerID)
+        : InputController(eventBroker)
+        , m_PlayerID(playerID)
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_ELockMouse, &FirstPersonInputController::OnLockMouse);
+        EVENT_SUBSCRIBE_MEMBER(m_EUnlockMouse, &FirstPersonInputController::OnUnlockMouse);
     }
 
-    void LockMouse();
-    void UnlockMouse();
-    virtual bool OnCommand(const Events::InputCommand& e) override;
-    virtual void Reset();
+    const glm::quat Orientation() const { return m_Orientation; }
+    
+    void LockMouse()
+    {
+        Events::LockMouse e;
+        m_EventBroker->Publish(e);
+        m_MouseLocked = true;
+    }
 
-protected:
-    const int m_PlayerID;
-    bool m_MouseLocked = false;
-    glm::vec3 m_Rotation;
-    glm::vec3 m_Movement;
-    bool m_Jumping = false;
-    bool m_DoubleJumping = false;
-    bool m_Crouching = false;
+    void UnlockMouse()
+    {
+        Events::UnlockMouse e;
+        m_EventBroker->Publish(e);
+        m_MouseLocked = false;
+    }
 
-    EventRelay<EventContext, Events::LockMouse> m_ELockMouse;
-    bool OnLockMouse(const Events::LockMouse& e);
-    EventRelay<EventContext, Events::UnlockMouse> m_EUnlockMouse;
-    bool OnUnlockMouse(const Events::UnlockMouse& e);
-};
+    virtual bool OnCommand(const Events::InputCommand& e) override
+    {
+        if (m_PlayerID != e.PlayerID) {
+            return false;
+        }
 
-template <typename EventContext>
-FirstPersonInputController<EventContext>::FirstPersonInputController(EventBroker* eventBroker, int playerID)
-    : InputController(eventBroker)
-    , m_PlayerID(playerID)
-{
-    EVENT_SUBSCRIBE_MEMBER(m_ELockMouse, &FirstPersonInputController::OnLockMouse);
-    EVENT_SUBSCRIBE_MEMBER(m_EUnlockMouse, &FirstPersonInputController::OnUnlockMouse);
-}
+        if (m_MouseLocked) {
+            if (e.Command == "Pitch") {
+                float val = glm::radians(e.Value);
+                m_Orientation = m_Orientation * glm::angleAxis<float>(-val, glm::vec3(1, 0, 0));
+                return true;
+            }
 
-template <typename EventContext>
-void FirstPersonInputController<EventContext>::Reset()
-{
-    m_Rotation = glm::vec3(0.f, 0.f, 0.f);
-    m_Jumping = false;
-}
+            if (e.Command == "Yaw") {
+                float val = glm::radians(e.Value);
+                m_Orientation = glm::angleAxis<float>(-val, glm::vec3(0, 1, 0)) * m_Orientation;
+                return true;
+            }
+        }
 
-template <typename EventContext>
-void FirstPersonInputController<EventContext>::LockMouse()
-{
-    Events::LockMouse e;
-    m_EventBroker->Publish(e);
-    m_MouseLocked = true;
-}
-
-template <typename EventContext>
-void FirstPersonInputController<EventContext>::UnlockMouse()
-{
-    Events::UnlockMouse e;
-    m_EventBroker->Publish(e);
-    m_MouseLocked = false;
-}
-
-template <typename EventContext>
-bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputCommand& e)
-{
-    if (m_PlayerID != e.PlayerID) {
         return false;
     }
 
-    if (e.Command == "Pitch") {
-        float val = glm::radians(e.Value);
-        m_Rotation.x += -val;
-        //m_Rotation.x = glm::clamp(m_Rotation.x, -glm::half_pi<float>(), glm::half_pi<float>());
-    }
-
-    if (e.Command == "Yaw") {
-        float val = glm::radians(e.Value);
-        m_Rotation.y += -val;
-    }
-
-    if (e.Command == "Forward" || e.Command == "Right") {
-        if (e.Command == "Forward") {
-            float val = glm::clamp(e.Value, -1.f, 1.f);
-            m_Movement.z = -val;
-        }
-        if (e.Command == "Right") {
-            float val = glm::clamp(e.Value, -1.f, 1.f);
-            m_Movement.x = val;
-        }
-        if (glm::length2(m_Movement) > 0) {
-            m_Movement = glm::normalize(m_Movement);
-        }
-    }
-
-    if (e.Command == "Jump") {
-        m_Jumping = e.Value > 0;
-    }
-
-    if (e.Command == "Crouch") {
-        m_Crouching = e.Value > 0;
-    }
-
-    return true;
-}
-
-template <typename EventContext>
-bool FirstPersonInputController<EventContext>::OnUnlockMouse(const Events::UnlockMouse& e)
-{
-    m_MouseLocked = false;
-    return true;
-}
-
-template <typename EventContext>
-bool FirstPersonInputController<EventContext>::OnLockMouse(const Events::LockMouse& e)
-{
-    m_MouseLocked = true;
-    return true;
-}
+protected:
+    const unsigned int m_PlayerID;
+    glm::quat m_Orientation;
+    bool m_MouseLocked = false;
+    
+    EventRelay<EventContext, Events::LockMouse> m_ELockMouse;
+    bool OnLockMouse(const Events::LockMouse& e) { m_MouseLocked = true; return true; }
+    EventRelay<EventContext, Events::UnlockMouse> m_EUnlockMouse;
+    bool OnUnlockMouse(const Events::UnlockMouse& e) { m_MouseLocked = false; return true; }
+};
 
 #endif

include/Engine/Network/Client.h

@@ -20,7 +20,6 @@
 #include "Input/EInputCommand.h"
 #include "Core/EPlayerDamage.h"
 #include "Network/EInterpolate.h"
-#include "Core/EPlayerSpawned.h"
 
 class Client : public Network
 {
@@ -36,21 +35,20 @@ private:
     boost::asio::ip::udp::socket m_Socket;
 
     // Sending message to server logic
-    size_t bytesRead = 0;
+    int bytesRead = -1;
     char readBuf[INPUTSIZE] = { 0 };
 
     // Packet loss logic
-    PacketID m_PacketID = 0;
-    PacketID m_PreviousPacketID = 0;
-    PacketID m_SendPacketID = 0;
+    unsigned int m_PacketID = 0;
+    unsigned int m_PreviousPacketID = 0;
+    unsigned int m_SendPacketID = 0;
 
     // Game logic
     World* m_World;
     std::string m_PlayerName;
-    PlayerID m_PlayerID = -1;
+    int m_PlayerID = -1;
     EntityID m_ServerEntityID = std::numeric_limits<EntityID>::max();
     bool m_IsConnected = false;
-    EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
     // Server Client Lookup map
     // Assumes that root node for client and server is EntityID 0.
 
@@ -59,36 +57,31 @@ private:
     std::unordered_map<EntityID, EntityID> m_ClientIDToServerID;
 
     // Network logic
-    PlayerDefinition m_PlayerDefinitions[8];
+    PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
     SnapshotDefinitions m_NextSnapshot;
     double m_DurationOfPingTime;
     std::clock_t m_StartPingTime;
-    std::clock_t m_TimeSinceSentInputs;
-    unsigned int m_SendInputIntervalMs;
     std::vector<Events::InputCommand> m_InputCommandBuffer;
 
     // Private member functions
     void readFromServer();
-    size_t  receive(char* data);
+    int  receive(char* data, size_t length);
     void send(Packet& packet);
     void connect();
     void disconnect();
+    void ping();
     void parseMessageType(Packet& packet);
     void updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType);
     void parseConnect(Packet& packet);
     void parsePlayerConnected(Packet& packet);
     void parsePing();
-    void parseKick();
-    void parsePlayersSpawned(Packet& packet);
-    void parseEntityDeletion(Packet& packet);
-    void parseComponentDeletion(Packet& packet);
+    void parseServerPing();
     void InterpolateFields(Packet & packet, const ComponentInfo & componentInfo, const EntityID & entityID, const std::string & componentType);
     void parseSnapshot(Packet& packet);
     void identifyPacketLoss();
     bool hasServerTimedOut();
     EntityID createPlayer();
     void sendInputCommands();
-    void sendLocalPlayerTransform();
     void becomePlayer();
     // Mapping Logic
     // Returns if local EntityID exist in map
@@ -96,16 +89,13 @@ private:
     // Returns if server EntityID exist in map
     bool serverClientMapsHasEntity(EntityID serverEntityID);
     void insertIntoServerClientMaps(EntityID serverEntityID, EntityID clientEntityID);
-    void deleteFromServerClientMaps(EntityID serverEntityID, EntityID clientEntityID);
 
     // Events
     EventBroker* m_EventBroker;
     EventRelay<Client, Events::InputCommand> m_EInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);
-    EventRelay<Client, Events::PlayerDamage> m_EPlayerDamage;
+    EventRelay<Client, Events::PlayerDamage> m_EPlayeDamage;
     bool OnPlayerDamage(const Events::PlayerDamage& e);
-    EventRelay<Client, Events::PlayerSpawned> m_EPlayerSpawned;
-    bool OnPlayerSpawned(const Events::PlayerSpawned& e);
 };
 
 #endif

include/Engine/Network/EPlayerDisconnected.h

@@ -1,18 +0,0 @@
-#ifndef Events_PlayerDisconnected
-#define Events_PlayerDisconnected
-
-#include "Core/EventBroker.h"
-#include "Core/Entity.h"
-
-namespace Events
-{
-
-struct PlayerDisconnected : public Event
-{
-    unsigned int PlayerID;
-    EntityID Entity;
-};
-
-}
-
-#endif

include/Engine/Network/MessageType.h

@@ -5,20 +5,16 @@
 // Used to determine what type of message was sent.
 enum class MessageType
 {
-    Connect,
-    Disconnect,
-    Ping,
-    Message,
-    Snapshot,
+	Connect,
+	Disconnect,
+	ClientPing,
+	ServerPing,
+	Message,
+	Snapshot,
     OnInputCommand,
     OnPlayerDamage,
     PlayerConnected,
-    BecomePlayer,
-    Kick,
-    OnPlayerSpawned,
-    EntityDeleted,
-    ComponentDeleted,
-    PlayerTransform
+    BecomePlayer
 };
 
 #endif

include/Engine/Network/Network.h

@@ -1,20 +1,13 @@
 #ifndef Network_h__
 #define Network_h__
 
-#include <ctime>
-
 #include "Core/World.h"
 #include "Core/EventBroker.h"
 #include "Network/Packet.h"
-#include "Network/NetworkData.h"
-#include "Core/ResourceManager.h"
-#include "Core/ConfigFile.h"
-#include <fstream>
-#include <iostream>
 
-#define INPUTSIZE 32000
-typedef unsigned int PlayerID;
-typedef unsigned int PacketID;
+#define MAXCONNECTIONS 8
+#define INPUTSIZE 4097
+#define TIMEOUTMS 15000
 
 class Network
 {
@@ -22,17 +15,6 @@ public:
     virtual ~Network() { };
     virtual void Start(World* m_world, EventBroker *eventBroker) = 0;
     virtual void Update() = 0;
-protected:
-    // For Debug 
-    bool isReadingData = false;
-    NetworkData m_NetworkData;
-    unsigned int m_SaveDataIntervalMs = 1000;
-    std::clock_t m_SaveDataTimer;
-    unsigned int m_MaxConnections;
-    double m_TimeoutMs;
-    void saveToFile();
-    void updateNetworkData();
-    void initialize();
 };
 
 #endif

include/Engine/Network/NetworkData.h

@@ -1,18 +0,0 @@
-#ifndef NetworkData_h__
-#define NetworkData_h__
-#include <vector>
-
-struct NetworkData {
-    double TotalTime = 0;
-    size_t TotalDataReceived = 0;
-    size_t TotalDataSent = 0;
-    size_t AmountOfMessagesReceived = 0;
-    unsigned int AmountOfMessagesSent = 0;
-    // Interval based
-    size_t DataReceivedThisInterval = 0;
-    size_t DataSentThisInterval = 0;
-    // pair: first=reveived, second=send 
-    std::vector<std::pair<size_t, size_t>> BandwidthBytes;
-};
-
-#endif

include/Engine/Network/Packet.h

@@ -13,7 +13,7 @@ public:
     // arg2: PacketID for identifying packet loss.
     Packet(MessageType type, unsigned int& packetID);
     // Used to create packet from already existing data buffer.
-    Packet(char* data, const size_t sizeOfPacket);
+    Packet(char* data, const int sizeOfPacket);
     Packet(MessageType type);
     ~Packet();
     void Init(MessageType type, unsigned int& packetID);
@@ -51,18 +51,16 @@ public:
     std::string ReadString();
     char* ReadData(int SizeOfData);
     void ChangePacketID(unsigned int& packetID);
-    size_t Size() { return m_Offset; };
+    int Size() { return m_Offset; };
     char* Data() { return m_Data; };
-    size_t DataReadSize() { return m_ReturnDataOffset; }
-    size_t MaxSize() { return m_MaxPacketSize; }
-    size_t HeaderSize() { return m_HeaderSize; }
+    unsigned int DataReadSize() { return m_ReturnDataOffset; }
+    unsigned int MaxSize() { return m_MaxPacketSize; }
 
 private:
     char* m_Data;
-    size_t m_ReturnDataOffset = 0;
-    size_t m_Offset = 0;
-    size_t m_MaxPacketSize = 512;
-    size_t m_HeaderSize = 0;
+    unsigned int m_ReturnDataOffset = 0;
+    int m_Offset = 0;
+    unsigned int m_MaxPacketSize = 512;
     void resizeData();
 };
 

include/Engine/Network/PlayerDefinition.h

@@ -1,10 +1,9 @@
 #ifndef PlayerDefinition_h__
 #define PlayerDefinition_h__
 #include <string>
-#include "../Core/Entity.h"
 
 struct PlayerDefinition {
-    ::EntityID EntityID = EntityID_Invalid;
+    int EntityID = -1;
     std::string Name = "";
     boost::asio::ip::udp::endpoint Endpoint;
     unsigned int PacketID;

include/Engine/Network/Server.h

@@ -14,10 +14,6 @@
 #include "../Network/Network.h"
 #include "Input/EInputCommand.h"
 #include "Core/EPlayerDamage.h"
-#include "Network/EPlayerDisconnected.h"
-#include "Core/EPlayerSpawned.h"
-#include "Core/EEntityDeleted.h"
-#include "Core/EComponentDeleted.h"
 
 class Server : public Network
 {
@@ -33,19 +29,18 @@ private:
     boost::asio::ip::udp::socket m_Socket;
 
     // Sending messages to client logic
-    std::map<PlayerID, PlayerDefinition> m_ConnectedPlayers;
-    // HACK: Fix INPUTSIZE
+    PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
+    std::vector<PlayerDefinition> m_ConnectedUsers;
     char readBuffer[INPUTSIZE] = { 0 };
-    size_t bytesRead = 0;
+    int bytesRead = 0;
     // time for previouse message
     std::clock_t previousePingMessage = std::clock();
     std::clock_t previousSnapshotMessage = std::clock();
     std::clock_t timOutTimer = std::clock();
     // How often we send messages (milliseconds)
-    float pingIntervalMs;
-    float snapshotInterval;
+    int intervalMs = 1000;
+    int snapshotInterval = 50;
     int checkTimeOutInterval = 100;
-    int m_NextPlayerID = 0;
 
     //Timers
     std::clock_t m_StartPingTime;
@@ -55,40 +50,32 @@ private:
     EventBroker* m_EventBroker;
     
     // Packet loss logic
-    PacketID m_PacketID = 0;
-    PacketID m_PreviousPacketID = 0;
+    unsigned int m_PacketID = 0;
+    unsigned int m_PreviousPacketID = 0;
 
     // Private member functions
-    size_t receive(char* data);
+    int  receive(char* data, size_t length);
     void readFromClients();
-    void send(PlayerID player, Packet& packet);
+    void send(Packet& packet, int playerID);
     void send(Packet& packet);
     void broadcast(Packet& packet);
     void sendSnapshot();
-    void addChildrenToPacket(Packet& packet, EntityID entityID);
     void sendPing();
     void checkForTimeOuts();
-    void disconnect(PlayerID playerID);
+    void disconnect(int i);
     void parseMessageType(Packet& packet);
     void parseOnInputCommand(Packet& packet);
     void parseOnPlayerDamage(Packet& packet);
     void parseConnect(Packet& packet);
     void parseDisconnect();
     void parseClientPing();
-    void parsePing();
+    void parseServerPing();
     void identifyPacketLoss();
-    void kick(PlayerID player);
-    PlayerID GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint);
+    void createPlayer();
+    int GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint);
     // Debug event
     EventRelay<Server, Events::InputCommand> m_EInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);
-    EventRelay<Server, Events::PlayerSpawned> m_EPlayerSpawned;
-    bool OnPlayerSpawned(const Events::PlayerSpawned& e);
-    EventRelay<Server, Events::EntityDeleted> m_EEntityDeleted;
-    bool OnEntityDeleted(const Events::EntityDeleted& e);
-    EventRelay<Server, Events::ComponentDeleted> m_EComponentDeleted;
-    bool OnComponentDeleted(const Events::ComponentDeleted& e);
-    void parsePlayerTransform(Packet& packet);
 };
 
 #endif

include/Engine/Rendering/AnimationSystem.h

@@ -1,29 +0,0 @@
-#ifndef AnimationSystem_h__
-#define AnimationSystem_h__
-
-#include "GLM.h"
-
-#include "Common.h"
-#include "Core/System.h"
-#include "Core/ResourceManager.h"
-#include "Rendering/Model.h"
-#include "Rendering/EAnimationComplete.h"
-#include "Rendering/Skeleton.h"
-
-class AnimationSystem : public PureSystem
-{
-public:
-    AnimationSystem(World* world, EventBroker* eventBroker)
-        : System(world, eventBroker)
-        , PureSystem("Animation")
-    {
-
-    }
-    ~AnimationSystem() { }
-    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& animationComponent, double dt) override;
-private:
-
-
-};
-
-#endif

include/Engine/Rendering/DebugCameraInputController.h

@@ -0,0 +1,84 @@
+#ifndef DebugCameraInputController_h__
+#define DebugCameraInputController_h__
+
+#include <imgui/imgui.h>
+#include "../Input/FirstPersonInputController.h"
+#include "../Core/EMousePress.h"
+#include "../Core/EMouseRelease.h"
+
+template <typename EventContext>
+class DebugCameraInputController : public FirstPersonInputController<EventContext>
+{
+public:
+    DebugCameraInputController(EventBroker* eventBroker, unsigned int playerID)
+        : FirstPersonInputController(eventBroker, playerID)
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &DebugCameraInputController::OnMousePress);
+        EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &DebugCameraInputController::OnMouseRelease);
+    }
+
+    void SetPosition(const glm::vec3 position) { m_Position = position; }
+    void SetOrientation(const glm::quat orientation) { m_Orientation = orientation; }
+
+    const glm::vec3 Position() const { return m_Position; }
+    void SetBaseSpeed(float speed) { m_BaseSpeed = speed; }
+
+    virtual bool OnCommand(const Events::InputCommand& e) override
+    {
+        ImGuiIO& io = ImGui::GetIO();
+
+        if (!io.WantCaptureKeyboard) {
+            if (e.Command == "Right") {
+                float value = std::max(-1.f, std::min(e.Value, 1.f));
+                m_Velocity.x = value;
+            }
+            if (e.Command == "Forward") {
+                float value = std::max(-1.f, std::min(e.Value, 1.f));
+                m_Velocity.z = -value;
+            }
+            if (e.Command == "Sprint") {
+                if (e.Value > 0.f) {
+                    m_Speed = m_BaseSpeed * 2.f * (e.Value);
+                } else {
+                    m_Speed = m_BaseSpeed;
+                }
+            }
+        }
+
+        return FirstPersonInputController::OnCommand(e);
+    }
+
+    void Update(double dt)
+    {
+        if (glm::length2(m_Velocity) > 0) {
+            m_Position += m_Orientation * (glm::normalize(m_Velocity) * m_Speed * (float)dt);
+        }
+    }
+
+protected:
+    glm::vec3 m_Position = glm::vec3(0, 0, 0);
+    glm::vec3 m_Velocity = glm::vec3(0, 0, 0);
+    float m_BaseSpeed = 2.0f;
+    float m_Speed = m_BaseSpeed;
+    EventRelay<EventContext, Events::MousePress> m_EMousePress;
+    bool OnMousePress(const Events::MousePress& e)
+    {
+        if (e.Button == GLFW_MOUSE_BUTTON_2) {
+            ImGuiIO& io = ImGui::GetIO();
+            if (!io.WantCaptureMouse) {
+                LockMouse();
+            }
+        }
+        return true;
+    }
+    EventRelay<EventContext, Events::MouseRelease> m_EMouseRelease;
+    bool OnMouseRelease(const Events::MouseRelease& e)
+    {
+        if (e.Button == GLFW_MOUSE_BUTTON_2) {
+            UnlockMouse();
+        }
+        return true;
+    }
+};
+
+#endif

include/Engine/Rendering/DrawBloomPass.h

@@ -1,53 +0,0 @@
-#ifndef DrawBloomPass_h__
-#define DrawBloomPass_h__
-
-#include "IRenderer.h"
-#include "DrawBloomPassState.h"
-//#include "LightCullingPass.h" Finalpass om den skall skickas in
-#include "FrameBuffer.h"
-#include "ShaderProgram.h"
-//#include "Util/UnorderedMapVec2.h"
-#include "Texture.h"
-
-class DrawBloomPass
-{
-public:
-    DrawBloomPass(IRenderer* renderer /* ,Texture or finalpass*/ );
-    ~DrawBloomPass() { }
-    void InitializeTextures();
-    void InitializeFrameBuffers();
-    void InitializeShaderPrograms();
-    void InitializeBuffers();
-    void ClearBuffer();
-
-    void FillGaussianBuffer(FrameBuffer* fb);
-
-    void Draw(GLuint texture);
-
-    //Getters
-    //Return the blurred result of the texture that was sent into draw
-    GLuint GaussianTexture() const { return m_GaussianTexture_vert; }
-
-
-private:
-    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
-
-    Texture* m_WhiteTexture;
-    Model* m_ScreenQuad;
-
-    const IRenderer* m_Renderer;
-    //const LightCullingPass* m_LightCullingPass 
-    GLuint m_iterations = 9;
-
-    GLuint m_GaussianTexture_horiz;
-    GLuint m_GaussianTexture_vert;
-
-    FrameBuffer m_GaussianFrameBuffer_horiz;
-    FrameBuffer m_GaussianFrameBuffer_vert;
-
-    ShaderProgram* m_GaussianProgram_horiz;
-    ShaderProgram* m_GaussianProgram_vert;
-
-};
-
-#endif 

include/Engine/Rendering/DrawBloomPassState.h

@@ -1,15 +0,0 @@
-#ifndef DrawBloomPassState_h__
-#define DrawBloomPassState_h__
-
-#include "Rendering/RenderState.h"
-
-class DrawBloomPassState : public RenderState
-{
-public:
-    DrawBloomPassState();
-    ~DrawBloomPassState();
-private:
-
-};
-
-#endif

include/Engine/Rendering/DrawColorCorrectionPass.h

@@ -1,29 +0,0 @@
-#ifndef DrawColorCorrectionPass_h__
-#define DrawColorCorrectionPass_h__
-
-#include "IRenderer.h"
-#include "DrawScreenQuadPassState.h"
-#include "FrameBuffer.h"
-#include "ShaderProgram.h"
-//#include "Util/UnorderedMapVec2.h"
-#include "Texture.h"
-#include "imgui/imgui.h"
-
-class DrawColorCorrectionPass
-{
-public:
-    DrawColorCorrectionPass(IRenderer* renderer);
-    ~DrawColorCorrectionPass() { }
-    void InitializeFrameBuffers();
-    void InitializeShaderPrograms();
-
-    void Draw(GLuint sceneTexture, GLuint bloomTexture, GLfloat gamma, GLfloat exposure);
-private:
-    const IRenderer* m_Renderer;
-
-    ShaderProgram* m_ColorCorrectionProgram;
-
-    Model* m_ScreenQuad;
-};
-
-#endif 

include/Engine/Rendering/DrawFinalPass.h

@@ -17,42 +17,22 @@ public:
     void InitializeTextures();
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
-    void Draw(RenderScene& scene);
-    void ClearBuffer();
 
-    //Return the texture that is used in later stages to apply the bloom effect
-    GLuint BloomTexture() const { return m_BloomTexture; }
-    //Return the texture with diffuse and lighting of the scene.
-    GLuint SceneTexture() const { return m_SceneTexture; }
-    FrameBuffer* FinalPassFrameBuffer() { return &m_FinalPassFrameBuffer; }
+    void Draw(RenderScene& scene);
+
+    //Getters
 
 
 private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
-    void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const;
-    void DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& job, RenderScene& scene);
-
-    void BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene);
-    void BindModelUniforms(GLuint shaderHandle, std::shared_ptr<ModelJob>& job, RenderScene& scene);
-
-    void BindExplosionTextures(std::shared_ptr<ExplosionEffectJob>& job);
-    void BindModelTextures(std::shared_ptr<ModelJob>& job);
 
     Texture* m_WhiteTexture;
-    Texture* m_BlackTexture;
-    Texture* m_NeutralNormalTexture;
-    Texture* m_GreyTexture;
-
-    FrameBuffer m_FinalPassFrameBuffer;
-    GLuint m_BloomTexture;
-    GLuint m_SceneTexture;
-    GLuint m_DepthBuffer;
+	Texture* m_NeutralNormalMap;
 
     const IRenderer* m_Renderer;
     const LightCullingPass* m_LightCullingPass;
 
     ShaderProgram* m_ForwardPlusProgram;
-    ShaderProgram* m_ExplosionEffectProgram;
 };
 
 #endif 

include/Engine/Rendering/DrawFinalPassState.h

@@ -6,7 +6,7 @@
 class DrawFinalPassState : public RenderState
 {
 public:
-    DrawFinalPassState(GLuint frameBuffer);
+    DrawFinalPassState();
     ~DrawFinalPassState();
 private:
 

include/Engine/Rendering/DrawScreenQuadPass.h

@@ -1,28 +0,0 @@
-#ifndef DrawScreenQuadPass_h__
-#define DrawScreenQuadPass_h__
-
-#include "IRenderer.h"
-#include "DrawScreenQuadPassState.h"
-#include "FrameBuffer.h"
-#include "ShaderProgram.h"
-//#include "Util/UnorderedMapVec2.h"
-#include "Texture.h"
-
-class DrawScreenQuadPass
-{
-public:
-    DrawScreenQuadPass(IRenderer* renderer);
-    ~DrawScreenQuadPass() { }
-    void InitializeFrameBuffers();
-    void InitializeShaderPrograms();
-
-    void Draw(GLuint texture);
-private:
-    const IRenderer* m_Renderer;
-
-    ShaderProgram* m_DrawQuadProgram;
-
-    Model* m_ScreenQuad;
-};
-
-#endif 

include/Engine/Rendering/DrawScreenQuadPassState.h

@@ -1,15 +0,0 @@
-#ifndef DrawScreenQuadPassState_h__
-#define DrawScreenQuadPassState_h__
-
-#include "Rendering/RenderState.h"
-
-class DrawScreenQuadPassState : public RenderState
-{
-public:
-    DrawScreenQuadPassState();
-    ~DrawScreenQuadPassState();
-private:
-
-};
-
-#endif

include/Engine/Rendering/EAnimationComplete.h

@@ -1,18 +0,0 @@
-#ifndef Events_AnimationComplete_h__
-#define Events_AnimationComplete_h__
-
-#include "../Core/EventBroker.h"
-#include "../Core/EntityWrapper.h"
-
-namespace Events
-{
-
-struct AnimationComplete : Event
-{
-    EntityWrapper Entity;
-    std::string Name;
-};
-
-}
-
-#endif

include/Engine/Rendering/ExplosionEffectJob.h

@@ -1,106 +0,0 @@
-#ifndef ExplosionEffectJob_h__
-#define ExplosionEffectJob_h__
-
-#include <cstdint>
-
-#include "../Common.h"
-#include "../GLM.h"
-#include "../Core/ComponentWrapper.h"
-#include "Texture.h"
-#include "Model.h"
-#include "RenderJob.h"
-#include "../Core/ResourceManager.h"
-#include "Camera.h"
-#include "../Core/World.h"
-
-struct ExplosionEffectJob : ModelJob
-{
-    ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialGroup matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage)
-        : ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage)
-    {
-        ExplosionOrigin = (glm::vec3)explosionEffectComponent["ExplosionOrigin"];
-        TimeSinceDeath = (double)explosionEffectComponent["TimeSinceDeath"];
-        ExplosionDuration = (double)explosionEffectComponent["ExplosionDuration"];
-        EndColor = (glm::vec4)explosionEffectComponent["EndColor"];
-        Randomness = (bool)explosionEffectComponent["Randomness"];
-        RandomnessScalar = (double)explosionEffectComponent["RandomnessScalar"];
-        Velocity = (glm::vec2)explosionEffectComponent["Velocity"];
-        ColorByDistance = (bool)explosionEffectComponent["ColorByDistance"];
-        ExponentialAccelaration = (bool)explosionEffectComponent["ExponentialAccelaration"];
-    };
-
-    glm::vec3 ExplosionOrigin;
-    double TimeSinceDeath = 0.f; //Seconds
-    double ExplosionDuration = 2.f;
-    //bool Gravity = true;
-    //double GravityForce = 1.f; // Speed
-    //double ObjectRadius = 2.f; // TODO: Change this for object radius when it's available
-    glm::vec4 EndColor;
-    bool Randomness = false;
-    
-    float RandomnessScalar = 1.f;
-    glm::vec2 Velocity;
-    bool ColorByDistance = false;
-    //bool ReverseAnimation = false;
-    //bool Wireframe = false;
-    bool ExponentialAccelaration = false;
-
-    std::array<float, 50> RandomNumbers = {
-        0.3257552917701f,
-        0.07601508315467f,
-        0.57408909014151f,
-        0.0f,
-        0.8618231368539f,
-        0.074957156588769f,
-        0.39413607511396f,
-        0.54579346698979f,
-        0.83222648353885f,
-        0.83635707285086f,
-        0.34473986148124f,
-        0.98092448710507f,
-        0.46346380070944f,
-        0.7308761201477f,
-        0.70832470371776f,
-        0.28268750909841f,
-        0.26291620883295f,
-        0.07685032816457f,
-        0.30760929515008f,
-        0.2781575388639f   ,
-        0.016950582161988f  ,
-        0.25787915254844f   ,
-        0.76293767279151f   ,
-        0.67730279903733f   ,
-        0.49042877018937f   ,
-        0.13002237823327f   ,
-        0.62803373841012f   ,
-        0.94525353747665f   ,
-        0.32893980076953f   ,
-        0.95952951719962f   ,
-        0.056386206790985f  ,
-        0.012030893476694f  ,
-        0.93090049220757f,
-        0.83579883064879f,
-        0.79733513938139f,
-        0.8796381046435f    ,
-        0.94160434600972f   ,
-        0.76901855588379f   ,
-        0.50253688101775f   ,
-        0.82457069578793f   ,
-        0.80157403359263f   ,
-        0.87291810189975f   ,
-        0.64679548919517f   ,
-        0.42664138899494f   ,
-        0.77171308303797f   ,
-        0.75567959237643f   ,
-        0.45190826265696f   ,
-        0.59844922628181f   ,
-        0.56534937655802f   ,
-        0.195656257307f};
-
-    void CalculateHash() override
-    {
-        Hash = 0;
-    }
-};
-
-#endif

include/Engine/Rendering/Font.h

@@ -1,36 +0,0 @@
-#ifndef Font_h__
-#define Font_h__
-
-#include <ft2build.h>
-#include FT_FREETYPE_H  
-#include FT_GLYPH_H
-#include <boost/tokenizer.hpp>
-#include <boost/lexical_cast.hpp>
-
-#include "../OpenGL.h"
-#include "../GLM.h"
-#include "../Core/ResourceManager.h"
-
-class Font : public Resource
-{
-    friend class ResourceManager;
-private:
-    Font(std::string path);
-    
-public:
-    struct Character {
-        GLuint     TextureID;  // ID handle of the glyph texture
-        glm::ivec2 Size;       // Size of glyph
-        glm::ivec2 Bearing;    // Offset from baseline to left/top of glyph
-        GLuint     Advance;    // Offset to advance to next glyph
-    };
-
-    
-
-    int FontSize = 16;
-
-    ~Font();
-
-    std::map<GLchar, Character> m_Characters;
-};
-#endif

include/Engine/Rendering/IRenderer.h

@@ -25,23 +25,21 @@ class IRenderer
 {
 public:
 	GLFWwindow* Window() const { return m_Window; }
-    //Returns screen size including window border and header
 	Rectangle Resolution() const { return m_Resolution; }
-	virtual void SetResolution(const Rectangle& resolution) { m_Resolution = resolution; }
+	void SetResolution(const Rectangle& resolution) { m_Resolution = resolution; }
 	bool Fullscreen() { return m_Fullscreen; }
-	virtual void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
+	void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
 	bool VSYNC() const { return m_VSYNC; }
-	virtual void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
-    //Returns screen size excluding window border and header
-    Rectangle GetViewportSize() const { return m_ViewportSize; }
+	void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
 	virtual void Initialize() = 0;
 	virtual void Update(double dt) = 0;
 	virtual void Draw(RenderFrame& rq) = 0;
     virtual PickData Pick(glm::vec2 screenCord) = 0;
 
+    World* m_World; //Temp world, untill viktor merge.
+
 protected:
 	Rectangle m_Resolution = Rectangle::Rectangle(1280, 720);
-    Rectangle m_ViewportSize = Rectangle::Rectangle(1280, 720);
 	bool m_Fullscreen = false;
 	bool m_VSYNC = false;
 	int m_GLVersion[2];

include/Engine/Rendering/Model.h

@@ -1,8 +1,7 @@
 #ifndef Model_h__
 #define Model_h__
 
-#include "Rendering/RawModelCustom.h"
-//#include "Rendering/RawModelAssimp.h"
+#include "RawModel.h"
 #include "../OpenGL.h"
 
 class Model : public ThreadUnsafeResource
@@ -20,11 +19,12 @@ public:
 
 	GLuint VAO;
 	GLuint ElementBuffer;
-    RawModel* m_RawModel;
 
 private:
-    
+    RawModel* m_RawModel;
 	GLuint VertexBuffer;
+	GLuint DiffuseVertexColorBuffer;
+	GLuint SpecularVertexColorBuffer;
 	GLuint NormalBuffer;
 	GLuint TangentNormalsBuffer;
 	GLuint BiTangentNormalsBuffer;

include/Engine/Rendering/ModelJob.h

@@ -13,38 +13,17 @@
 #include "Camera.h"
 #include "../Core/World.h"
 #include "../Core/Transform.h"
-#include "Skeleton.h"
 
 struct ModelJob : RenderJob
 {
-    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialGroup matGroup, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage)
+    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialGroup matGroup, ComponentWrapper modelComponent, World* world)
         : RenderJob()
     {
         Model = model;
         TextureID = (matGroup.Texture) ? matGroup.Texture->ResourceID : 0;
-        if (modelComponent["DiffuseTexture"]) {
-            DiffuseTexture = matGroup.Texture.get();
-        } else {
-            DiffuseTexture = nullptr;
-        }
-        if (modelComponent["NormalMap"]) {
-            NormalTexture = matGroup.NormalMap.get();
-        } else {
-            NormalTexture = nullptr;
-        }
-        if (modelComponent["SpecularMap"]) {
-            SpecularTexture = matGroup.SpecularMap.get();
-        } else {
-            SpecularTexture = nullptr;
-        }
-        if (modelComponent["GlowMap"]) {
-            IncandescenceTexture = matGroup.IncandescenceMap.get();
-        } else {
-            IncandescenceTexture = nullptr;
-        }
-        DiffuseColor = matGroup.DiffuseColor;
-        SpecularColor = matGroup.SpecularColor;
-        IncandescenceColor = matGroup.IncandescenceColor;
+        DiffuseTexture = matGroup.Texture.get();
+        NormalTexture = matGroup.NormalMap.get();
+        SpecularTexture = matGroup.SpecularMap.get();
         StartIndex = matGroup.StartIndex;
         EndIndex = matGroup.EndIndex;
         Matrix = matrix;
@@ -54,16 +33,6 @@ struct ModelJob : RenderJob
         glm::vec3 worldpos = glm::vec3(camera->ViewMatrix() * glm::vec4(abspos, 1));
         Depth = worldpos.z;
         World = world;
-
-        FillColor = fillColor;
-        FillPercentage = fillPercentage;
-        Skeleton = Model->m_RawModel->m_Skeleton;
-
-        if (world->HasComponent(Entity, "Animation") && Skeleton != nullptr) {
-            auto animationComponent = world->GetComponent(Entity, "Animation");
-            Animation = model->m_RawModel->m_Skeleton->GetAnimation(animationComponent["Name"]);
-            AnimationTime = (double)animationComponent["Time"];
-        }
     };
 
     unsigned int TextureID;
@@ -74,25 +43,13 @@ struct ModelJob : RenderJob
     const Texture* DiffuseTexture;
     const Texture* NormalTexture;
     const Texture* SpecularTexture;
-    const Texture* IncandescenceTexture;
     float Shininess = 0.f;
     glm::vec4 Color;
     const ::Model* Model = nullptr;
-    ::Skeleton* Skeleton = nullptr;
-    const ::Skeleton::Animation* Animation = nullptr;
-
-    float AnimationTime = 0.f;
-
-    glm::vec4 DiffuseColor;
-    glm::vec4 SpecularColor;
-    glm::vec4 IncandescenceColor;
     unsigned int StartIndex = 0;
     unsigned int EndIndex = 0;
     World* World;
 
-    glm::vec4 FillColor = glm::vec4(0);
-    float FillPercentage = 0.0;
-
     void CalculateHash() override
     {
         Hash = TextureID;

include/Engine/Rendering/PickingPass.h

@@ -1,6 +1,8 @@
 #ifndef PickingPass_h__
 #define PickingPass_h__
 
+
+
 #include "IRenderer.h"
 #include "PickingPassState.h"
 #include "FrameBuffer.h"
@@ -8,7 +10,8 @@
 #include "Util/UnorderedMapiVec2.h"
 #include "../Core/EventBroker.h"
 #include "../Core/World.h"
-#include "Rendering/Skeleton.h"
+
+
 
 class PickingPass
 {

include/Engine/Rendering/RawModel.h

@@ -1,7 +1,5 @@
-#ifndef RawModelAssimp_h__
-#define RawModelAssimp_h__
-
-#ifdef USING_ASSIMP_AS_IMPORTER
+#ifndef RawModel_h__
+#define RawModel_h__
 
 #include <fstream>
 #include <iostream>
@@ -20,27 +18,29 @@
 #include "Texture.h"
 #include "Skeleton.h"
 
-#define RawModel RawModelAssimp
-
-class RawModelAssimp : public Resource
+class RawModel : public Resource
 {
 	friend class ResourceManager;
 
 protected:
-    RawModelAssimp(std::string fileName);
+	RawModel(std::string fileName);
 
 public:
-	~RawModelAssimp();
+	~RawModel();
 
 	struct Vertex
 	{
 		glm::vec3 Position;
 		glm::vec3 Normal;
 		glm::vec3 Tangent;
-		glm::vec3 BiNormal;
+		glm::vec3 BiTangent;
 		glm::vec2 TextureCoords;
-		glm::vec4 BoneIndices;
-		glm::vec4 BoneWeights;
+		glm::vec4 DiffuseVertexColor;
+		glm::vec4 SpecularVertexColor;
+		glm::vec4 BoneIndices1;
+		glm::vec4 BoneIndices2;
+		glm::vec4 BoneWeights1;
+		glm::vec4 BoneWeights2;
 	};
 
 	struct MaterialGroup
@@ -68,6 +68,8 @@ private:
 	std::vector<glm::ivec2> BoneIndices;
 	std::vector<glm::vec2> BoneWeights;
 	std::vector<glm::vec3> Normals;
+	std::vector<glm::vec4> DiffuseVertexColor;
+	std::vector<glm::vec4> SpecularVertexColor;
 	std::vector<glm::vec3> TangentNormals;
 	std::vector<glm::vec3> BiTangentNormals;
 	std::vector<glm::vec2> TextureCoords;
@@ -76,4 +78,3 @@ private:
 };
 
 #endif
-#endif

include/Engine/Rendering/RawModelCustom.h

@@ -1,102 +0,0 @@
-#ifndef RawModelCustom_h__
-#define RawModelCustom_h__
-
-#ifndef USING_ASSIMP_AS_IMPORTER
-
-#define RawModel RawModelCustom
-
-#include <fstream>
-#include <iostream>
-#include <sstream>
-#include <cstdlib>
-#include <stack>
-
-#include <boost/filesystem/path.hpp>
-
-#include "../Common.h"
-#include "../GLM.h"
-#include "../Core/ResourceManager.h"
-#include "Texture.h"
-#include "Skeleton.h"
-
-#include "boost\endian\buffers.hpp"
-
-
-
-class RawModelCustom : public Resource
-{
-    friend class ResourceManager;
-
-protected:
-    RawModelCustom(std::string fileName);
-
-public:
-    ~RawModelCustom();
-    
-    struct Vertex
-    {
-        glm::vec3 Position;
-        glm::vec3 Normal;
-        glm::vec3 Tangent;
-        glm::vec3 BiNormal;
-        glm::vec2 TextureCoords;
-        glm::vec4 BoneIndices;
-        glm::vec4 BoneWeights;
-    };
-
-    struct MaterialGroup
-    {
-        float SpecularExponent;
-        float ReflectionFactor;
-        glm::vec4 DiffuseColor{ 1.0f, 1.0f, 1.0f, 1.0f };
-        glm::vec4 SpecularColor{ 1.0f, 1.0f, 1.0f, 1.0f };
-        glm::vec4 IncandescenceColor{ 1.0f, 1.0f, 1.0f, 1.0f };
-        unsigned int StartIndex;
-        unsigned int EndIndex;
-        //float Transparency;
-        std::string TexturePath;
-        std::shared_ptr<::Texture> Texture;
-        std::string NormalMapPath;
-        std::shared_ptr<::Texture> NormalMap;
-        std::string SpecularMapPath;
-        std::shared_ptr<::Texture> SpecularMap;
-        std::string IncandescenceMapPath;
-        std::shared_ptr<::Texture> IncandescenceMap;
-    };
-
-    std::vector<MaterialGroup> MaterialGroups;
-
-    std::vector<Vertex> m_Vertices;
-    std::vector<unsigned int> m_Indices;
-    Skeleton* m_Skeleton = nullptr;
-    glm::mat4 m_Matrix;
-
-private:
-   
-
-    void ReadMeshFile(std::string filePath);
-    void ReadMeshFileHeader(std::size_t& offset, char* fileData);
-    void ReadMesh(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
-    void ReadVertices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
-    void ReadIndices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
-
-    void ReadMaterialFile(std::string filePath);
-    void ReadMaterials(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
-    void ReadMaterialSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
-
-    void ReadAnimationFile(std::string filePath);
-    void ReadAnimationBindPoses(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
-    void ReadAnimationJoint(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
-    void ReadAnimationClips(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int numberOfClips);
-    void ReadAnimationClipSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int clipIndex);
-    void ReadAnimationKeyFrame(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int numberOfJoints, Skeleton::Animation& animation);
-    
-    //void CreateSkeleton(std::vector<std::tuple<std::string, glm::mat4>> &boneInfo, std::map<std::string, int> &boneNameMapping, aiNode* node, int parentID);
-};
-
-#else
-
-#include "RawModelAssimp.h"
-
-#endif
-#endif

include/Engine/Rendering/RenderQueue.h

@@ -11,29 +11,57 @@
 #include "Camera.h"
 #include "RenderJob.h"
 #include "ModelJob.h"
-#include "TextJob.h"
 #include "PointLightJob.h"
 #include "DirectionalLightJob.h"
-#include "ExplosionEffectJob.h"
+
+
+/*
+struct SpriteJob : RenderJob
+{
+	unsigned int ShaderID = 0;
+	unsigned int TextureID = 0;
+
+	glm::mat4 ModelMatrix;
+	const Texture* DiffuseTexture = nullptr;
+	const Texture* NormalTexture = nullptr;
+	const Texture* SpecularTexture = nullptr;
+	glm::vec4 Color;
+
+	void CalculateHash() override
+	{
+		Hash = TextureID;
+	}
+};
+
+struct PointLightJob : RenderJob
+{
+    glm::vec4 Position;
+	glm::vec4 Color;
+	float Radius;
+    float Intensity;
+    float Falloff;
+    float padding = 123;
+
+	void CalculateHash() override
+	{
+		Hash = 0;
+	}
+};
+*/
 
 struct RenderScene
 {
     ::Camera* Camera = nullptr;
-    std::list<std::shared_ptr<RenderJob>> OpaqueObjects;
-    std::list<std::shared_ptr<RenderJob>> TransparentObjects;
+    std::list<std::shared_ptr<RenderJob>> ForwardJobs;
     std::list<std::shared_ptr<RenderJob>> PointLightJobs;
-    std::list<std::shared_ptr<RenderJob>> TextJobs;
     std::list<std::shared_ptr<RenderJob>> DirectionalLightJobs;
     Rectangle Viewport;
     bool ClearDepth = false;
-    glm::vec4 AmbientColor;
 
 	void Clear()
 	{
-        OpaqueObjects.clear();
-        TransparentObjects.clear();
+        ForwardJobs.clear();
         PointLightJobs.clear();
-        TextJobs.clear();
         DirectionalLightJobs.clear();
 	}
 };
@@ -41,9 +69,6 @@ struct RenderScene
 struct RenderFrame
 {
 public:
-    //TODO: Getters
-    GLfloat Gamma = 2.2f;
-    GLfloat Exposure = 1.f;
 
     void Add(RenderScene &scene)
     {
@@ -73,4 +98,5 @@ public:
 private:
     int m_Size = 0;
 };
+
 #endif

include/Engine/Rendering/RenderSystem.h

@@ -15,7 +15,7 @@
 #include "Renderer.h"
 #include "PointLightJob.h"
 #include "../Core/Transform.h"
-#include "../Core/EPlayerSpawned.h"
+#include "DebugCameraInputController.h"
 
 class RenderSystem : public ImpureSystem
 {
@@ -29,25 +29,17 @@ private:
     const IRenderer* m_Renderer;
     RenderFrame* m_RenderFrame;
     Camera* m_Camera;
-    World* m_World;
     EntityWrapper m_CurrentCamera = EntityWrapper::Invalid;
-    EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
 
     EventRelay<RenderSystem, Events::SetCamera> m_ESetCamera;
     bool OnSetCamera(Events::SetCamera &event);
-    EventRelay<RenderSystem, Events::InputCommand> m_EInputCommand;
-    bool OnInputCommand(const Events::InputCommand& e);
-    EventRelay<RenderSystem, Events::PlayerSpawned> m_EPlayerSpawned;
-    bool OnPlayerSpawned(Events::PlayerSpawned& e);
-
-    void fillModels(std::list<std::shared_ptr<RenderJob>>& opaqueJobs, std::list<std::shared_ptr<RenderJob>>& transparentJobs);
-    void fillText(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
     void fillPointLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
     void fillDirectionalLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
-    void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs);
-    bool isChildOfACamera(EntityWrapper entity);
-    bool isChildOfCurrentCamera(EntityWrapper entity);
+    EventRelay<RenderSystem, Events::InputCommand> m_EInputCommand;
+    bool OnInputCommand(const Events::InputCommand& e);
 
+    void fillModels(std::list<std::shared_ptr<RenderJob>>& jobs);
+    void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs);
 };
 
 #endif

include/Engine/Rendering/Renderer.h

@@ -13,15 +13,10 @@
 #include "PickingPass.h"
 #include "LightCullingPass.h"
 #include "DrawFinalPass.h"
-#include "DrawScreenQuadPass.h"
-#include "DrawBloomPass.h"
-#include "DrawColorCorrectionPass.h"
 #include "../Core/EventBroker.h"
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
 #include "../Core/Transform.h"
-#include "imgui/imgui.h"
-#include "TextPass.h"
 
 class Renderer : public IRenderer
 {
@@ -39,7 +34,6 @@ public:
 private:
     //----------------------Variables----------------------//
     EventBroker* m_EventBroker;
-    TextPass* m_TextPass;
 
     Texture* m_ErrorTexture;
     Texture* m_WhiteTexture;
@@ -48,15 +42,10 @@ private:
     Model* m_UnitQuad;
     Model* m_UnitSphere;
 
-    int m_DebugTextureToDraw = 0;
-
     PickingPass* m_PickingPass;
     LightCullingPass* m_LightCullingPass;
     ImGuiRenderPass* m_ImGuiRenderPass;
     DrawFinalPass* m_DrawFinalPass;
-    DrawScreenQuadPass* m_DrawScreenQuadPass;
-    DrawBloomPass* m_DrawBloomPass;
-    DrawColorCorrectionPass* m_DrawColorCorrectionPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();
@@ -66,15 +55,14 @@ private:
     //TODO: Renderer: Get InputUpdate out of renderer
     void InputUpdate(double dt);
     //void PickingPass(RenderQueueCollection& rq);
-    //void DrawScreenQuad(GLuint textureToDraw);
+    void DrawScreenQuad(GLuint textureToDraw);
 
     static bool DepthSort(const std::shared_ptr<RenderJob> &i, const std::shared_ptr<RenderJob> &j) { return (i->Depth < j->Depth); }
     void SortRenderJobsByDepth(RenderScene &scene);
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type);
 	//--------------------ShaderPrograms-------------------//
-    ShaderProgram* m_BasicForwardProgram;
-    ShaderProgram* m_ExplosionEffectProgram;
-
+	ShaderProgram* m_BasicForwardProgram;
+    ShaderProgram* m_DrawScreenQuadProgram;
 };
 
 #endif

include/Engine/Rendering/Skeleton.h

@@ -4,7 +4,6 @@
 #include <sstream>
 #include "Common.h"
 #include "../GLM.h"
-#include <glm/gtx/matrix_decompose.hpp>
 
 //struct Bone
 //{
@@ -39,9 +38,9 @@ public:
 			, OffsetMatrix(offsetMatrix)
 		{ }
 
+		int ID;
 		std::string Name;
 		glm::mat4 OffsetMatrix;
-        int ID;
 
 		Bone* Parent;
 		std::vector<Bone*> Children;

include/Engine/Rendering/TextJob.h

@@ -1,58 +0,0 @@
-#ifndef TextJob_h__
-#define TextJob_h__
-
-#include <cstdint>
-
-#include "../Common.h"
-#include "../GLM.h"
-#include "../Core/ComponentWrapper.h"
-#include "Texture.h"
-#include "RenderJob.h"
-#include "../Core/ResourceManager.h"
-#include "Font.h"
-
-struct TextJob : RenderJob
-{
-    TextJob(glm::mat4 matrix, Font* font, ComponentWrapper textComponent)
-        : RenderJob()
-    {
-        Matrix = matrix;
-        Color = (glm::vec4)textComponent["Color"];
-        Content = (std::string)textComponent["Content"];
-        Resource = font;
-
-        if ((int)textComponent["Alignment"] == textComponent["Alignment"].Enum("Left")) {
-            Alignment = AlignmentEnum::Left;
-        } else if ((int)textComponent["Alignment"] == textComponent["Alignment"].Enum("Right")) {
-            Alignment = AlignmentEnum::Right;
-        } else if ((int)textComponent["Alignment"] == textComponent["Alignment"].Enum("Center")) {
-            Alignment = AlignmentEnum::Center;
-        } else {
-            LOG_ERROR("Text alignment invalid");
-            Alignment = AlignmentEnum::Left;
-        }
-
-    };
-
-    enum class AlignmentEnum
-    {
-        Left,
-        Right,
-        Center
-    };
-
-    glm::mat4 Matrix;
-    glm::vec4 Color;
-    std::string Content;
-    Font* Resource;
-    AlignmentEnum Alignment;
-
-    
-
-    void CalculateHash() override
-    {
-        Hash = 0;
-    }
-};
-
-#endif

include/Engine/Rendering/TextPass.h

@@ -1,33 +0,0 @@
-#ifndef TextRenderer_h__
-#define TextRenderer_h__
-
-#include <ft2build.h>
-#include FT_FREETYPE_H
-
-#include "../OpenGL.h"
-#include "../GLM.h"
-#include "ShaderProgram.h"
-#include "Font.h"
-#include "../Core/ResourceManager.h"
-#include "RenderQueue.h"
-#include "TextPassState.h"
-#include "FrameBuffer.h"
-
-class TextPass
-{
-public:
-    TextPass();
-    void Initialize();
-    void Update();
-    void Draw(RenderScene& scene, FrameBuffer& frameBuffer);
-
-private:
-    void renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix);
-
-    Font* font;
-    GLuint VAO, VBO;
-    ShaderProgram* m_TextProgram;
-};
-
-
-#endif

include/Engine/Rendering/TextPassState.h

@@ -1,15 +0,0 @@
-#ifndef TextPassState_h__
-#define TextPassState_h__
-
-#include "Rendering/RenderState.h"
-
-class TextPassState : public RenderState
-{
-public:
-    TextPassState(GLuint frameBuffer);
-    ~TextPassState();
-private:
-
-};
-
-#endif

include/Engine/Rendering/Texture.h

@@ -18,7 +18,6 @@ public:
 	void Bind(GLenum textureUnit = GL_TEXTURE0);
 
 	GLuint m_Texture = 0;
-    
 };
 
 #endif

include/Engine/Rendering/Util/CommonFunctions.h

@@ -1,17 +0,0 @@
-#ifndef CommonFuntions_h__
-#define CommonFuntions_h__
-
-#include "../../Common.h"
-#include "../../OpenGL.h"
-#include "../../GLM.h"
-
-class CommonFuntions
-{
-public:
-    CommonFuntions() = delete;
-
-private:
-
-};
-
-#endif

include/Engine/Rendering/Util/GLError.h

@@ -9,7 +9,7 @@ inline bool _GLERROR(const char* info, const char* file, const char* func, unsig
 	GLenum error = glGetError();
 	if (error != GL_NO_ERROR)
 	{
-		_LOG(LOG_LEVEL_ERROR, file, func, line, "GL Error: %s\nError code: %i, %s\n", info, error, gluErrorString(error));
+		_LOG(LOG_LEVEL_ERROR, file, func, line, "GL Error: %s, %i, %s", info, error, gluErrorString(error));
 		return true;
 	}
 

include/Game/ExplosionEffectSystem.h

@@ -1,24 +0,0 @@
-#include "Common.h"
-#include "Core/System.h"
-
-class ExplosionEffectSystem : public PureSystem
-{
-public:
-    ExplosionEffectSystem(World* world, EventBroker* eventBroker)
-        : System(world, eventBroker)
-        , PureSystem("ExplosionEffect")
-    { }
-
-    virtual void  UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
-    {
-
-        if ((double)component["TimeSinceDeath"] > (double)component["ExplosionDuration"]) {
-            (double)component["TimeSinceDeath"] = 0.f;
-        }
-        (double&)component["TimeSinceDeath"] += dt;
-
-        //if ((bool)Component["Gravity"] == true) {
-        //    (bool)Component["ExponentialAccelaration"] = false;
-        //}
-    }
-};

include/Game/Game.h

@@ -14,15 +14,12 @@
 #include "Core/EKeyDown.h"
 #include "Core/EntityFilePreprocessor.h"
 #include "Core/SystemPipeline.h"
-#include "ExplosionEffectSystem.h"
 #include "Editor/EditorSystem.h"
 #include "Core/EntityFile.h"
 #include "Rendering/RenderSystem.h"
 #include "Core/EntityFileParser.h"
 #include "Core/Octree.h"
-#include "Rendering/Font.h"
 #include "Systems/InterpolationSystem.h"
-#include "Collision/EntityAABB.h"
 // Network
 #include <boost/thread.hpp>
 #include "Network/Network.h"
@@ -50,9 +47,8 @@ private:
     InputProxy* m_InputProxy;
 	GUI::Frame* m_FrameStack;
     World* m_World;
-    Octree<EntityAABB>* m_OctreeCollision;
-    Octree<EntityAABB>* m_OctreeTrigger;
-    Octree<EntityAABB>* m_OctreeFrustrumCulling;
+    Octree<AABB>* m_OctreeCollision;
+    Octree<AABB>* m_OctreeFrustrumCulling;
     SystemPipeline* m_SystemPipeline;
     RenderFrame* m_RenderFrame;
     // Network variables

include/Game/Systems/CapturePointSystem.h

@@ -40,7 +40,7 @@ private:
     int m_BlueTeamHomeCapturePoint = m_NotACapturePoint;
 
     int m_NumberOfCapturePoints = 0;
-    std::map<int, EntityWrapper> m_CapturePointNumberToEntityMap;
+    std::map<int, EntityID> m_CapturePointNumberToEntityIDMap;
 
     //std::vector<ComponentWrapper>
 
@@ -48,8 +48,8 @@ private:
     bool m_ResetTimers = false;
 
     //vectors which will keep track of enter/leave changes
-    std::vector<std::tuple<EntityWrapper, EntityWrapper>> m_ETriggerTouchVector;
-    std::vector<std::tuple<EntityWrapper, EntityWrapper>> m_ETriggerLeaveVector;
+    std::vector<std::tuple<EntityID, EntityID>> m_ETriggerTouchVector;
+    std::vector<std::tuple<EntityID, EntityID>> m_ETriggerLeaveVector;
 };
 
 #endif

include/Game/Systems/HealthSystem.h

@@ -24,7 +24,7 @@ public:
 private:
     //methods which will take care of specific events
     EventRelay<HealthSystem, Events::PlayerDamage> m_EPlayerDamage;
-    bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e);
+    bool HealthSystem::OnPlayerDamaged(const Events::PlayerDamage& e);
     EventRelay<HealthSystem, Events::PlayerHealthPickup> m_EPlayerHealthPickup;
     bool HealthSystem::OnPlayerHealthPickup(const Events::PlayerHealthPickup& e);
 

include/Game/Systems/InterpolationSystem.h

@@ -10,12 +10,11 @@
 #include "Common.h"
 #include "Core/System.h"
 #include "Core/EventBroker.h"
-#include "Core/ResourceManager.h"
-#include "Core/ConfigFile.h"
-#include "Core/EPlayerSpawned.h"
 
 #include "Network/EInterpolate.h"
 
+#define SNAPSHOTINTERVAL 0.05f
+
 class InterpolationSystem : public PureSystem
 {
     struct Transform 
@@ -23,31 +22,32 @@ class InterpolationSystem : public PureSystem
         glm::vec3 Position;
         glm::vec3 Scale;
         glm::quat Orientation;
-        float interpolationTime;
+        double interpolationTime;
     };
 public:
-    InterpolationSystem(World* world, EventBroker* eventBroker);
+    InterpolationSystem(World* world, EventBroker* eventBroker)
+        : System(world, eventBroker)
+        , PureSystem("Transform")
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_EInterpolate, &InterpolationSystem::OnInterpolate);
+    }
     ~InterpolationSystem() { }
     virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& transform, double dt) override;
 private:
     std::unordered_map<EntityID, Transform> m_NextTransform;
     std::unordered_map<EntityID, Transform> m_LastReceivedTransform;
-    EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
 
     //glm::vec3 vectorInterpolation(glm::vec3 prev, glm::vec3 next, double currentTime);
     template <typename T>
     T vectorInterpolation(T prev, T next, double currentTime)
     {
         T difference = next - prev;
-        T vector = (difference / m_SnapshotInterval) * static_cast<float>(currentTime);
+        T vector = (difference / SNAPSHOTINTERVAL) * static_cast<float>(currentTime);
         return vector;
     }
-    float m_SnapshotInterval;
 
     EventRelay<InterpolationSystem, Events::Interpolate> m_EInterpolate;
     bool InterpolationSystem::OnInterpolate(const Events::Interpolate& e);
-    EventRelay<InterpolationSystem, Events::PlayerSpawned> m_EPlayerSpawned;
-    bool OnPlayerSpawned(Events::PlayerSpawned& e);
 };
 
 #endif

include/Game/Systems/LifetimeSystem.h

@@ -1,21 +0,0 @@
-#ifndef LifetimeSystem_h__
-#define LifetimeSystem_h__
-
-#include "Core/System.h"
-
-class LifetimeSystem : public ImpureSystem, PureSystem
-{
-public:
-    LifetimeSystem(World* world, EventBroker* eventBroker)
-        : System(world, eventBroker)
-        , PureSystem("Lifetime")
-    { }
-
-    virtual void Update(double dt) override;
-    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cLifetime, double dt) override;
-
-private:
-    std::vector<EntityWrapper> m_Deletions;
-};
-
-#endif

include/Game/Systems/PlayerHUD.h

@@ -1,23 +0,0 @@
-#ifndef PlayerHUD_h__
-#define PlayerHUD_h__
-
-#include "../../Engine/Core/System.h"
-#include "../../Engine/GLM.h"
-#include "../../Engine/Rendering/ESetCamera.h"
-#include <imgui/imgui.h>
-
-class PlayerHUD : public ImpureSystem
-{
-public:
-    PlayerHUD(World* world, EventBroker* eventBrokerer);
-    ~PlayerHUD();
-
-    virtual void Update(double dt) override;
-
-private:
-    World* m_World;
-    EventBroker* m_EventBroker;
-
-};
-
-#endif

include/Game/Systems/PlayerMovementSystem.h

@@ -1,23 +1,14 @@
 #include "Common.h"
 #include "GLM.h"
 #include "Core/System.h"
-#include "Core/EPlayerSpawned.h"
-#include "Input/FirstPersonInputController.h"
-#include <imgui/imgui.h>
 
-class PlayerMovementSystem : public ImpureSystem, PureSystem
+class PlayerMovementSystem : public PureSystem
 {
 public:
-    PlayerMovementSystem(World* world, EventBroker* eventBroker);
-    ~PlayerMovementSystem();
+    PlayerMovementSystem(World* world, EventBroker* eventBroker)
+        : System(world, eventBroker)
+        , PureSystem("Player")
+    { }
 
-    virtual void Update(double dt) override;
     virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt);
-
-private:
-    // State
-    std::unordered_map<EntityWrapper, FirstPersonInputController<PlayerMovementSystem>*> m_PlayerInputControllers;
-
-    EventRelay<PlayerMovementSystem, Events::PlayerSpawned> m_EPlayerSpawned;
-    bool OnPlayerSpawned(Events::PlayerSpawned& e);
 };

include/Game/Systems/PlayerSpawnSystem.h

@@ -2,9 +2,6 @@
 #include "Input/EInputCommand.h"
 #include "Systems/SpawnerSystem.h"
 #include "Events/ESpawnerSpawn.h"
-#include "Core/EPlayerSpawned.h"
-#include "Rendering/ESetCamera.h"
-#include "Core/ConfigFile.h"
 
 class PlayerSpawnSystem : public ImpureSystem
 {
@@ -14,18 +11,8 @@ public:
     virtual void Update(double dt) override;
 
 private:
-    struct SpawnRequest
-    {
-        int PlayerID;
-        ComponentInfo::EnumType Team;
-    };
-
-    bool m_NetworkEnabled = false;
-    std::vector<SpawnRequest> m_SpawnRequests;
-    std::map<int, EntityWrapper> m_PlayerEntities;
-
     EventRelay<PlayerSpawnSystem, Events::InputCommand> m_OnInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);
-    EventRelay<PlayerSpawnSystem, Events::PlayerSpawned> m_OnPlayerSpawnerd;
-    bool OnPlayerSpawned(Events::PlayerSpawned& e);
+
+    std::vector<int> m_SpawnRequests;
 };

include/Game/Systems/WeaponSystem.h

@@ -9,10 +9,7 @@
 #include "Core/System.h"
 #include "Core/EPlayerDamage.h"
 #include "Core/EShoot.h"
-#include "Core/EPlayerSpawned.h"
 #include "Input/EInputCommand.h"
-#include "Core/EntityFile.h"
-#include "Core/EntityFileParser.h"
 
 #include <tuple>
 #include <vector>
@@ -26,18 +23,16 @@ public:
     virtual void Update(double dt) override;
 
 private:
-    IRenderer* m_Renderer;
-
-    // State
-    EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
-
-    // Events
-    EventRelay<WeaponSystem, Events::PlayerSpawned> m_EPlayerSpawned;
-    bool WeaponSystem::OnPlayerSpawned(const Events::PlayerSpawned& e);
+    //methods which will take care of specific events
     EventRelay<WeaponSystem, Events::Shoot> m_EShoot;
-    bool WeaponSystem::OnShoot(Events::Shoot& e);
+    bool WeaponSystem::OnShoot(const Events::Shoot& e);
+
     EventRelay<WeaponSystem, Events::InputCommand> m_EInputCommand;
     bool WeaponSystem::OnInputCommand(const Events::InputCommand& e);
+
+    IRenderer* m_Renderer;
+
+    std::vector<std::tuple<EntityID, glm::vec2>> m_EShootVector;
 };
 
 #endif

resources/DefaultConfig.ini

@@ -1,13 +1,11 @@
 [Debug]
 LogLevel=1
 LoadMap=
+EditorEnabled=false
 ; if true -> Pool allocation is not used when calling Allocate/Free, just use regular dynamic allocation. 
 ; if false -> Use pool allocation.
 DisableMemoryPool=false
 
-[Editor]
-CameraSpeed=3
-
 [Video]
 Fullscreen=false
 VSYNC=false
@@ -21,11 +19,6 @@ IsServer=false
 Name=Bob
 Address=127.0.0.1
 Port=13
-MaxConnections=8
-SnapshotInterval=0.05
-SendInputIntervalMs=33
-PingIntervalMs= 1000
-TimeoutMs=15000
 
 [Multithreading]
 ResourceLoading=true

resources/DefaultInput.ini

@@ -15,7 +15,10 @@ Space=Jump
 LeftControl=Crouch
 LeftShift=Sprint
 F1=ToggleEditor
+1=EditorToolMove
+2=EditorToolRotate
+3=EditorToolScale
+X=EditorToggleTransformSpace
 C=ConnectToServer
 N=SwitchToServer
-M=SwitchToClient
-P=SwitchToPlayer
+M=SwitchToClient

resources/Schema/Components.xsd

@@ -6,14 +6,11 @@
 	<xs:include schemaLocation="Components/Model.xsd"/>
 	<xs:include schemaLocation="Components/RaptorCopter.xsd"/>
 	<xs:include schemaLocation="Components/Player.xsd"/>
-	<xs:include schemaLocation="Components/Text.xsd"/>
 	<xs:include schemaLocation="Components/Camera.xsd"/>
 	<xs:include schemaLocation="Components/AABB.xsd"/>
 	<xs:include schemaLocation="Components/PointLight.xsd"/>
 	<xs:include schemaLocation="Components/DirectionalLight.xsd"/>
-	<xs:include schemaLocation="Components/SceneLight.xsd"/>
 	<xs:include schemaLocation="Components/Trigger.xsd"/>
-	<xs:include schemaLocation="Components/ExplosionEffect.xsd"/>
 	<xs:include schemaLocation="Components/Health.xsd"/>
 	<xs:include schemaLocation="Components/CapturePoint.xsd"/>
 	<xs:include schemaLocation="Components/Listener.xsd"/>
@@ -25,9 +22,4 @@
 	<xs:include schemaLocation="Components/Team.xsd"/>
 	<xs:include schemaLocation="Components/UniformScale.xsd"/>
 	<xs:include schemaLocation="Components/EditorWidget.xsd"/>
-	<xs:include schemaLocation="Components/HealthHUD.xsd"/>
-	<xs:include schemaLocation="Components/Animation.xsd"/>
-	<xs:include schemaLocation="Components/Fill.xsd"/>
-	<xs:include schemaLocation="Components/Lifetime.xsd"/>
-	<xs:include schemaLocation="Components/HiddenForLocalPlayer.xsd"/>
 </xs:schema>

resources/Schema/Components/Animation.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<Animation xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Animation.xsd">
-	<Name></Name>
-	<Time>0</Time>
-	<Speed>0</Speed>
-	<Loop>true</Loop>
-</Animation>

resources/Schema/Components/Animation.xsd

@@ -1,16 +0,0 @@
-<?xml version="1.0"?>
-
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
-	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
-
-	<xs:element name="Animation">
-		<xs:complexType>
-			<xs:all>
-				<xs:element name="Name" type="t:string" minOccurs="0"/>
-				<xs:element name="Time" type="t:double" minOccurs="0"/>
-				<xs:element name="Speed" type="t:double" minOccurs="0"/>
-				<xs:element name="Loop" type="t:bool" minOccurs="0"/>
-			</xs:all>
-		</xs:complexType>
-	</xs:element>
-</xs:schema>

resources/Schema/Components/CapturePoint.xsd

@@ -2,11 +2,22 @@
 
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
 	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
-	<xs:include schemaLocation="../Types/TeamEnum.xsd"/>
+
+	<xs:complexType name="TeamEnum" mixed="true">
+		<xs:complexContent>
+			<xs:extension base="t:enum">
+				<xs:choice>
+					<xs:element name="Spectator" type="xs:integer" fixed="1" minOccurs="0"/>
+					<xs:element name="Red" type="xs:integer" fixed="2" minOccurs="0"/>
+					<xs:element name="Blue" type="xs:integer" fixed="3" minOccurs="0"/>
+				</xs:choice>
+			</xs:extension>
+		</xs:complexContent>
+	</xs:complexType>
 
 	<xs:element name="CapturePoint">
 		<xs:annotation>
-			<xs:documentation>A Capture Point. Make sure to update the HomePoint,CapturePointNumber,Team for each</xs:documentation>
+			<xs:documentation>A Capture Point. Add a Team Component to specify who currently owns it</xs:documentation>
 		</xs:annotation>
 		<xs:complexType>
 			<xs:all>

resources/Schema/Components/ExplosionEffect.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<ExplosionEffect xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ExplosionEffect.xsd">
-	<ExplosionOrigin X="0" Y="0" Z="0"/>
-	<TimeSinceDeath>0</TimeSinceDeath>
-	<ExplosionDuration>2</ExplosionDuration>
-	<!--<Gravity>1</Gravity>-->
-	<!--<GravityForce>1</GravityForce>-->
-	<!--<ObjectRadius>2</ObjectRadius>-->
-	<EndColor R="0" G="0" B="0" A="0"/>
-	<Randomness>0</Randomness>
-	<RandomnessScalar>1</RandomnessScalar>
-	<Velocity X="2" Y="2"/>
-	<ColorByDistance>0</ColorByDistance>
-	<!--<ReverseAnimation>0</ReverseAnimation>-->
-	<!--<Wireframe>0</Wireframe>-->
-	<ExponentialAccelaration>0</ExponentialAccelaration>
-</ExplosionEffect>

resources/Schema/Components/ExplosionEffect.xsd

@@ -1,57 +0,0 @@
-<?xml version="1.0"?>
-
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
-	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
-
-	<xs:element name="ExplosionEffect">
-		<xs:annotation>
-			<xs:documentation>A component that trigger the death effect</xs:documentation>
-		</xs:annotation>
-		<xs:complexType>
-			<xs:all>
-				<xs:element name="ExplosionOrigin" type="t:Vector" minOccurs="0">
-					<xs:annotation><xs:documentation>The position in which to spawn the component</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="TimeSinceDeath" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>Seconds since death</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="ExplosionDuration" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>How many seconds the death animation should be</xs:documentation></xs:annotation>
-				</xs:element>
-				<!--<xs:element name="Gravity" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Enable/disable gravity</xs:documentation></xs:annotation>
-				</xs:element>-->
-				<!--<xs:element name="GravityForce" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>The force of the gravity</xs:documentation></xs:annotation>
-				</xs:element>-->
-				<!--<xs:element name="ObjectRadius" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>Object radius (TO BE REMOVED AND AUTOMATED)</xs:documentation></xs:annotation>
-				</xs:element>-->
-				<xs:element name="EndColor" type="t:Color" minOccurs="0">
-					<xs:annotation><xs:documentation>The tint the polys end with</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="Randomness" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Add some randomness to the explosion</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="RandomnessScalar" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>Alter the power of the randomness</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="Velocity" type="t:Vector" minOccurs="0">
-					<xs:annotation><xs:documentation>The velocity factors (start/end)</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="ColorByDistance" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Change the color by its moved distance instead of by its time</xs:documentation></xs:annotation>
-				</xs:element>
-				<!--<xs:element name="ReverseAnimation" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Implosions are cooler</xs:documentation></xs:annotation>
-				</xs:element>-->
-				<!--<xs:element name="Wireframe" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Enable/disable wireframe</xs:documentation></xs:annotation>
-				</xs:element>-->
-				<xs:element name="ExponentialAccelaration" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Linear/Exponential accelaration</xs:documentation></xs:annotation>
-				</xs:element>
-			</xs:all>
-		</xs:complexType>
-	</xs:element>
-</xs:schema>

resources/Schema/Components/Fill.xml

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<Fill xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Fill.xsd">
-	<Percentage>0.0</Percentage>
-	<Color R="1" G="1" B="1" A="1"/>
-</Fill>

resources/Schema/Components/Fill.xsd

@@ -1,14 +0,0 @@
-<?xml version="1.0"?>
-
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
-	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
-
-	<xs:element name="Fill">
-		<xs:complexType>
-			<xs:all>
-				<xs:element name="Percentage" type="t:double" minOccurs="0"/>
-				<xs:element name="Color" type="t:Color" minOccurs="0"/>
-			</xs:all>
-		</xs:complexType>
-	</xs:element>
-</xs:schema>

resources/Schema/Components/HealthHUD.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<HealthHUD xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="HealthHUD.xsd"/>

resources/Schema/Components/HealthHUD.xsd

@@ -1,8 +0,0 @@
-<?xml version="1.0"?>
-
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
-	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
-
-	<xs:element name="HealthHUD">
-	</xs:element>
-</xs:schema>

resources/Schema/Components/HiddenForLocalPlayer.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<HiddenForLocalPlayer xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="HiddenForLocalPlayer.xsd"/>

resources/Schema/Components/HiddenForLocalPlayer.xsd

@@ -1,11 +0,0 @@
-<?xml version="1.0"?>
-
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
-	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
-
-	<xs:element name="HiddenForLocalPlayer">
-		<xs:annotation>
-			<xs:documentation>Used to make the entity invisible if it's parented to the current local player entity (for first person player model and such)</xs:documentation>
-		</xs:annotation>
-	</xs:element>
-</xs:schema>

resources/Schema/Components/Lifetime.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<Lifetime xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Lifetime.xsd">
-	<Lifetime>0</Lifetime>
-</Lifetime>

resources/Schema/Components/Lifetime.xsd

@@ -1,13 +0,0 @@
-<?xml version="1.0"?>
-
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
-	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
-
-	<xs:element name="Lifetime">
-		<xs:complexType>
-			<xs:all>
-				<xs:element name="Lifetime" type="t:double" minOccurs="0"/>
-			</xs:all>
-		</xs:complexType>
-	</xs:element>
-</xs:schema>

resources/Schema/Components/Model.xml

@@ -2,10 +2,5 @@
 <Model xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Model.xsd">
 	<Resource></Resource>
 	<Color R="1" G="1" B="1" A="1"/>
-	<Transparent>false</Transparent>
 	<Visible>true</Visible>
-	<DiffuseTexture>true</DiffuseTexture>
-	<NormalMap>true</NormalMap>
-	<SpecularMap>true</SpecularMap>
-	<GlowMap>true</GlowMap>
 </Model>

resources/Schema/Components/Model.xsd

@@ -15,23 +15,8 @@
 				<xs:element name="Color" type="t:Color" minOccurs="0">
 					<xs:annotation><xs:documentation>Color tint</xs:documentation></xs:annotation>
 				</xs:element>
-				<xs:element name="Transparent" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Wether the model is transparent or not</xs:documentation></xs:annotation>
-				</xs:element>
 				<xs:element name="Visible" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Whether the model is visible or not</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="DiffuseTexture" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Whether the model should use the Diffuse texture or not</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="NormalMap" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Whether the model should use the Normalmap or not</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="SpecularMap" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Whether the model should use the Specularmap or not</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="GlowMap" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Whether the model should use the Glowmap or not</xs:documentation></xs:annotation>
+					<xs:annotation><xs:documentation>Wether the model is visible or not</xs:documentation></xs:annotation>
 				</xs:element>
 			</xs:all>
 		</xs:complexType>

resources/Schema/Components/Player.xml

@@ -1,5 +1,8 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
 <Player xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Player.xsd">
-	<MovementSpeed>3</MovementSpeed>
-	<CrouchSpeed>1.5</CrouchSpeed>
+	<Velocity X="0" Y="0" Z="0"/>
+	<Forward>false</Forward>
+	<Left>false</Left>
+	<Back>false</Back>
+	<Right>false</Right>
 </Player>

resources/Schema/Components/Player.xsd

@@ -9,8 +9,11 @@
 		</xs:annotation>
 		<xs:complexType>
 			<xs:all>
-				<xs:element name="MovementSpeed" type="t:float" minOccurs="0"/>
-				<xs:element name="CrouchSpeed" type="t:float" minOccurs="0"/>
+				<xs:element name="Velocity" type="t:Vector" minOccurs="0"/>
+				<xs:element name="Forward" type="t:bool" minOccurs="0"/>
+				<xs:element name="Left" type="t:bool" minOccurs="0"/>
+				<xs:element name="Back" type="t:bool" minOccurs="0"/>
+				<xs:element name="Right" type="t:bool" minOccurs="0"/>
 			</xs:all>
 		</xs:complexType>
 	</xs:element>

resources/Schema/Components/SceneLight.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<SceneLight xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="SceneLight.xsd">
-	<AmbientColor R="0.2" G="0.2" B="0.2" A="1"/>
-	<Visible>true</Visible>
-	<Gamma>2.2</Gamma>
-	<Exposure>1</Exposure>
-</SceneLight>

resources/Schema/Components/SceneLight.xsd

@@ -1,25 +0,0 @@
-<?xml version="1.0"?>
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
-	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
-	<xs:element name="SceneLight">
-		<xs:annotation>
-			<xs:documentation>Some settings for the scene lighting</xs:documentation>
-		</xs:annotation>
-		<xs:complexType>
-			<xs:all>
-				<xs:element name="AmbientColor" type="t:Color" minOccurs="0">
-					<xs:annotation><xs:documentation>Color of the ambient light</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="Visible" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Wether the ambient light should be applied or not</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="Gamma" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>Gamma correction for the scene</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="Exposure" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>The exposure of the camera</xs:documentation></xs:annotation>
-				</xs:element>
-			</xs:all>
-		</xs:complexType>
-	</xs:element>
-</xs:schema>

resources/Schema/Components/Team.xsd

@@ -2,7 +2,18 @@
 
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
 	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
-	<xs:include schemaLocation="../Types/TeamEnum.xsd"/>
+
+	<xs:complexType name="TeamEnum" mixed="true">
+		<xs:complexContent>
+			<xs:extension base="t:enum">
+				<xs:choice>
+					<xs:element name="Spectator" type="xs:integer" fixed="1" minOccurs="0"/>
+					<xs:element name="Red" type="xs:integer" fixed="2" minOccurs="0"/>
+					<xs:element name="Blue" type="xs:integer" fixed="3" minOccurs="0"/>
+				</xs:choice>
+			</xs:extension>
+		</xs:complexContent>
+	</xs:complexType>
 	
 	<xs:element name="Team">
 		<xs:annotation>

resources/Schema/Components/Text.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<Text xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Text.xsd">
-	<Content>Text</Content>
-	<Resource></Resource>
-	<Color R="1" G="1" B="1" A="1"/>
-	<Visible>true</Visible>
-	<Alignment><Center/></Alignment>
-</Text>