Merge remote-tracking branch 'origin/master' into Kill-streak-sounds

include/Engine/Collision/Collision.h

@@ -84,6 +84,18 @@ bool AABBvsTriangles(const AABB& box,
     const std::vector<unsigned int>& modelIndices,
     const glm::mat4& modelMatrix);
 
+enum Output
+{
+    OutContained,
+    OutSeparated,
+    OutIntersecting
+};
+//Detects intersection and containment.
+Output AABBvsTrianglesWContainment(const AABB& box,
+    const RawModel::Vertex* modelVertices,
+    const std::vector<unsigned int>& modelIndices,
+    const glm::mat4& modelMatrix);
+
 //Return true if the boxes are intersecting.
 bool AABBVsAABB(const AABB& a, const AABB& b);
 //Return true if the boxes are intersecting.

include/Engine/Editor/EditorSystem.h

@@ -47,6 +47,7 @@ private:
     // Utility functions
     EntityWrapper importEntity(EntityWrapper parent, boost::filesystem::path filePath);
     void setWidgetMode(EditorGUI::WidgetMode mode);
+    bool isAnyParentMissingTransform(EntityID entityID);
 
     // GUI callbacks
     void OnEntitySelected(EntityWrapper entity);

include/Engine/Input/FirstPersonInputController.h

@@ -19,6 +19,7 @@ public:
     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 CrouchingLastFrame() const { return m_CrouchingLastFrame; }
     virtual bool DoubleJumping() const { return m_DoubleJumping; }
     virtual void SetDoubleJumping(bool isDoubleJumping) {
         m_DoubleJumping = isDoubleJumping;
@@ -44,6 +45,7 @@ protected:
     bool m_Jumping = false;
     bool m_DoubleJumping = false;
     bool m_Crouching = false;
+    bool m_CrouchingLastFrame = false;
     //assault dash membervariables - needed to calculate the doubletap- and dashlogic
     double m_AssaultDashDoubleTapDeltaTime = 0.0;
     //i will let m_AssaultDashDoubleTapSensitivityTimer stay hardcoded, its not really a gamevariable (more an inputvariable), 
@@ -82,6 +84,7 @@ void FirstPersonInputController<EventContext>::Reset()
 {
     m_Rotation = glm::vec3(0.f, 0.f, 0.f);
     m_Jumping = false;
+    m_CrouchingLastFrame = m_Crouching;
 }
 
 template <typename EventContext>

include/Engine/Network/Client.h

@@ -42,7 +42,7 @@ public:
     void Connect(std::string address, int port);
     void Update() override;
 private:
-    //UDPClient m_Unreliable;
+    UDPClient m_Unreliable;
     TCPClient m_Reliable;
     std::vector<Events::PlayerSpawned> m_PlayerSpawnEvents;
     void parseSpawnEvents();
@@ -81,7 +81,7 @@ private:
     std::vector<Events::InputCommand> m_InputCommandBuffer;
 
     // Private member functions
-    size_t  receive(char* data);
+    size_t receive(char* data);
     void disconnect();
     void parseMessageType(Packet& packet);
     void updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID);
@@ -139,7 +139,7 @@ private:
     std::vector<ServerInfo> m_Serverlist;
     bool m_SearchingForServers = false;
     std::clock_t m_StartSearchTime;
-    double m_SearchingTime = 2000; // Config I guess
+    double m_SearchingTime = 200; // Config I guess
 };
 
 #endif

include/Engine/Network/Network.h

@@ -39,6 +39,7 @@ protected:
     void logReceivedData(int bytesReceived);
     void saveToFile();
     void updateNetworkData();
+    void popNetworkSegmentOfHeader(Packet& packet);
 };
 
 #endif

include/Engine/Network/Packet.h

@@ -16,7 +16,9 @@ public:
     Packet(char* data, const size_t sizeOfPacket);
     Packet(MessageType type);
     ~Packet();
-    void Init(MessageType type, unsigned int& packetID);
+    void Init(MessageType type, unsigned int& packetID,
+        int groupIndex, int groupSize,
+        int packetGroup);
 
     // Add primitive types like int, float, char...
     template<typename T>
@@ -25,7 +27,8 @@ public:
         // Check if we are trying to add more than the package can fit.
         if (m_MaxPacketSize < m_Offset + sizeof(T)) {
             if (m_MaxPacketSize >= 32000) {
-                LOG_WARNING("Package::WritePrimitive(): New size is huge %i bytes\n", m_MaxPacketSize*2);
+                // This will spam couse 8 players are over 100 000 bytes
+                //LOG_WARNING("Package::WritePrimitive(): New size is huge %i bytes\n", m_MaxPacketSize*2);
             }
             resizeData();
         }
@@ -57,13 +60,19 @@ public:
     void UpdateSize();
     char* ReadData(int SizeOfData);
     void ChangePacketID(unsigned int& packetID);
+    void ChangeGroupIndex(int groupIndex);
+    void ChangeGroupSize(int groupSize);
+    void ChangeGroup(int group);
     size_t Size() { return m_Offset; };
     char* Data() { return m_Data; };
     MessageType GetMessageType();
+    size_t Group();
     size_t DataReadSize() { return m_ReturnDataOffset; }
     size_t MaxSize() { return m_MaxPacketSize; }
     size_t HeaderSize() { return m_HeaderSize; }
-
+    size_t GroupIndex();
+    size_t GroupSize();
+    size_t PacketID();
 private:
     char* m_Data;
     size_t m_ReturnDataOffset = 0;
@@ -72,6 +81,13 @@ private:
     size_t m_HeaderSize = 0;
     void resizeData();
     void resizeData(int size);
+
+    size_t packetSizeOffset = 0;
+    size_t groupOffset = 0;
+    size_t groupIndexOffset = 0;
+    size_t groupSizeOffset = 0;
+    size_t messageTypeOffset = 0;
+    size_t packetIDOffset = 0;
 };
 
 #endif

include/Engine/Network/PlayerDefinition.h

@@ -14,6 +14,7 @@ struct PlayerDefinition {
     unsigned short TCPPort;
     // use for tcp connections
     boost::shared_ptr<boost::asio::ip::tcp::socket> TCPSocket;
+    int PacketGroup = 1;
 };
 
 #endif

include/Engine/Network/Server.h

@@ -36,7 +36,7 @@ public:
 private:
     // Network channels
     TCPServer m_Reliable;
-    //UDPServer m_Unreliable;
+    UDPServer m_Unreliable;
     UDPServer m_ServerlistRequest;
     // dont forget to set these in the childrens receive logic
     boost::asio::ip::address m_Address;

include/Engine/Network/UDPClient.h

@@ -1,5 +1,7 @@
 #ifndef UDPClient_h__
 #define UDPClient_h__
+#include <map>
+#include <algorithm>
 
 #include <boost/asio.hpp>
 #include "Network/NetworkClient.h"
@@ -13,16 +15,27 @@ public:
     bool Connect(std::string playerName, std::string address, int port);
     void Disconnect();
     void Receive(Packet& packet);
-    void Send(Packet & packet);
+    void ReceivePackets();
+    void Send(Packet& packet);
     void Broadcast(Packet& packet, int port);
     bool IsSocketAvailable();
+    // Returns false if no packets are available
+    bool GetNextPacket(Packet& packet);
 private:
+    typedef std::map<unsigned int, std::vector<std::pair<int, boost::shared_ptr<char>>>> PacketMap;
     // Assio UDP logic
     boost::asio::io_service m_IOService;
     boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
     boost::shared_ptr<boost::asio::ip::udp::socket> m_Socket;
+    int m_LastReceivedSnapshotGroup = 0;
     int readBuffer();
+    void readPartOfPacket();
     PacketID m_SendPacketID = 0;
+    //map:(packetGroup, vector:(pair:(groupIndex, packetData)))
+    PacketMap m_PacketSegmentMap;
+    bool hasReceivedPacket(int packetGroup, int groupIndex);
+    // 2^19
+    const int m_SizeOfSocketBuffer = 524288;
 };
 
 #endif

include/Engine/Network/UDPServer.h

@@ -3,6 +3,7 @@
 
 #include "NetworkServer.h"
 #include <boost/asio/ip/udp.hpp>
+#define MAXPACKETSIZE 64000
 
 class UDPServer : public NetworkServer
 {
@@ -13,6 +14,7 @@ public:
     void AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers);
     void Receive(Packet & packet, PlayerDefinition & playerDefinition);
     void Send(Packet & packet, PlayerDefinition & playerDefinition);
+    void SendToConnectedPlayers(Packet & packet, std::map<PlayerID, PlayerDefinition>& playersTosendTo);
     void Send(Packet & packet); 
     void Send(Packet & packet, boost::asio::ip::udp::endpoint endpoint);
     void Broadcast(Packet & packet, int port);

include/Engine/Rendering/DrawBloomPass.h

@@ -33,12 +33,14 @@ public:
 		if (m_Quality == 0) { 
 			return m_BlackTexture->m_Texture;
 		} else { 
-			return m_GaussianTexture_vert;
+			return m_FinalGaussianTexture;
 		} 
 	}
 
 
 private:
+    void GaussianLodPass(GLuint mipMap, GLuint texture);
+    void CombineGaussianBlur();
     Texture* m_BlackTexture;
     Model* m_ScreenQuad;
 
@@ -47,15 +49,19 @@ private:
     //const LightCullingPass* m_LightCullingPass 
     int m_Iterations;
 	int m_Quality = 0;
+    int m_BloomLod = 5;
 
     GLuint m_GaussianTexture_horiz = 0;
     GLuint m_GaussianTexture_vert = 0;
+    GLuint m_FinalGaussianTexture = 0;
 
-    FrameBuffer m_GaussianFrameBuffer_horiz;
-    FrameBuffer m_GaussianFrameBuffer_vert;
+    FrameBuffer* m_GaussianFrameBuffer_horiz = nullptr;
+    FrameBuffer* m_GaussianFrameBuffer_vert = nullptr;
+    FrameBuffer m_GaussianCombineBuffer;
 
     ShaderProgram* m_GaussianProgram_horiz;
     ShaderProgram* m_GaussianProgram_vert;
+    ShaderProgram* m_GaussianCombineProgram;
 
 };
 

include/Engine/Rendering/EResolutionChanged.h

@@ -0,0 +1,19 @@
+#ifndef EResolutionChanged_h__
+#define EResolutionChanged_h__
+
+#include "../Core/Event.h"
+#include "../Core/Util/Rectangle.h"
+
+namespace Events
+{
+
+// Fired when the framebuffer size changes
+struct ResolutionChanged : Event
+{
+    Rectangle OldResolution;
+    Rectangle NewResolution;
+};
+
+}
+
+#endif

include/Engine/Rendering/FrameBuffer.h

@@ -7,11 +7,12 @@
 class BufferResource
 {
 public:
-    BufferResource(GLuint* resourceHandle, GLenum resourceType, GLenum attachment);
+    BufferResource(GLuint* resourceHandle, GLenum resourceType, GLenum attachment, GLuint mipMapLod);
     
     GLuint* m_ResourceHandle;
     GLenum m_ResourceType;
     GLenum m_Attachment;
+    GLuint m_MipMapLod = 0;
 private:
     
 };
@@ -20,15 +21,15 @@ template <GLenum RESOURCETYPE>
 class ResourceType : public BufferResource
 {
 public:
-    ResourceType(GLuint* resourceHandle, GLenum attachment)
-        : BufferResource(resourceHandle, RESOURCETYPE, attachment) { }
+    ResourceType(GLuint* resourceHandle, GLenum attachment, GLuint mipMapLod)
+        : BufferResource(resourceHandle, RESOURCETYPE, attachment, mipMapLod) { }
 };
 
 class Texture2D : public ResourceType<GL_TEXTURE_2D>
 {
 public:
-    Texture2D(GLuint* resourceHandle, GLenum attachment)
-        : ResourceType(resourceHandle, attachment) { };
+    Texture2D(GLuint* resourceHandle, GLenum attachment, GLuint mipMapLod = 0)
+        : ResourceType(resourceHandle, attachment, mipMapLod) { };
 
     ~Texture2D();
 };
@@ -37,7 +38,7 @@ class RenderBuffer : public ResourceType<GL_RENDERBUFFER>
 {
 public:
     RenderBuffer(GLuint* resourceHandle, GLenum attachment)
-        : ResourceType(resourceHandle, attachment)
+        : ResourceType(resourceHandle, attachment, 0)
     { };
 
     ~RenderBuffer();
@@ -47,7 +48,7 @@ class Texture2DArray : public ResourceType<GL_TEXTURE_2D_ARRAY>
 {
 public:
 	Texture2DArray(GLuint* resourceHandle, GLenum attachment)
-		: ResourceType(resourceHandle, attachment)
+		: ResourceType(resourceHandle, attachment, 0)
 	{ };
 
 	~Texture2DArray();

include/Engine/Rendering/LightCullingPass.h

@@ -54,7 +54,7 @@ private:
     struct Frustum {
         Plane Planes[4];
     };
-    Frustum* m_Frustums;
+    Frustum* m_Frustums = nullptr;
 
     //This should be a component
     struct LightSource {
@@ -74,11 +74,11 @@ private:
         glm::vec2 Padding = glm::vec2(1.f, 2.f);
     };
 
-    LightGrid* m_LightGrid;
+    LightGrid* m_LightGrid = nullptr;
 
     int m_LightOffset = 0;
 
-    float* m_LightIndex;
+    float* m_LightIndex = nullptr;
 };
 
 

include/Engine/Rendering/ModelJob.h

@@ -26,24 +26,13 @@ struct ModelJob : RenderJob
 		ModelID = model->ResourceID;
 		Type = matProp.type;
 		::RawModel::MaterialBasic* matGroup = matProp.material;
+		ShaderID = matProp.ShaderID;
 		switch(matProp.type){
 		case ::RawModel::MaterialType::Basic:
-			if (Model->IsSkinned()) {
-				ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSkinnedProgram")->ResourceID;
-			}
-			else {
-				ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusProgram")->ResourceID;
-			}
 			TextureID = 0;
 			break;
 		case ::RawModel::MaterialType::SingleTextures:
 			{
-				if (Model->IsSkinned()) {
-					ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSkinnedProgram")->ResourceID;
-				}
-				else {
-					ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusProgram")->ResourceID;
-				}
 				::RawModel::MaterialSingleTextures* singleTextures = static_cast<::RawModel::MaterialSingleTextures*>(matProp.material);
 				TextureID = (singleTextures->ColorMap.Texture) ? singleTextures->ColorMap.Texture->ResourceID : 0;
 				if (modelComponent["DiffuseTexture"]) {
@@ -65,12 +54,6 @@ struct ModelJob : RenderJob
 			break;
 		case ::RawModel::MaterialType::SplatMapping:
 			{
-				if (Model->IsSkinned()) {
-					ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapSkinnedProgram")->ResourceID;
-				}
-				else {
-					ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapProgram")->ResourceID;
-				}
 				::RawModel::MaterialSplatMapping* SplatTextures = static_cast<::RawModel::MaterialSplatMapping*>(matProp.material);
 
 				SplatMap = &SplatTextures->SplatMap;

include/Engine/Rendering/RawModelCustom.h

@@ -18,6 +18,7 @@
 #include "../Core/ResourceManager.h"
 #include "Texture.h"
 #include "Skeleton.h"
+#include "ShaderProgram.h"
 
 #include "boost\endian\buffers.hpp"
 
@@ -87,6 +88,7 @@ public:
 	struct MaterialProperties {
 		MaterialType type;
 		MaterialBasic* material;
+		unsigned int ShaderID = 0;
 	};
 
 	const Vertex*	Vertices() const {

include/Engine/Rendering/RenderSystem.h

@@ -19,6 +19,7 @@
 #include "../Core/Octree.h"
 #include "../Collision/EntityAABB.h"
 #include "../Core/ConfigFile.h"
+#include "EResolutionChanged.h"
 
 class RenderSystem : public ImpureSystem
 {
@@ -36,6 +37,8 @@ private:
     EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
     Octree<EntityAABB>* m_Octree;
 
+    EventRelay<RenderSystem, Events::ResolutionChanged> m_EResolutionChanged;
+    bool OnResolutionChanged(Events::ResolutionChanged &event);
     EventRelay<RenderSystem, Events::SetCamera> m_ESetCamera;
     bool OnSetCamera(Events::SetCamera &event);
     EventRelay<RenderSystem, Events::InputCommand> m_EInputCommand;

include/Engine/Rendering/Renderer.h

@@ -28,10 +28,12 @@
 #include "Util/CommonFunctions.h"
 #include "Core/PerformanceTimer.h"
 #include "ShadowPass.h"
+#include "EResolutionChanged.h"
 
 class Renderer : public IRenderer
 {
     static void glfwFrameBufferCallback(GLFWwindow* window, int width, int height);
+    static void glfwWindowSizeCallback(GLFWwindow* window, int width, int height);
 
 public:
 	Renderer(EventBroker* eventBroker, ConfigFile* config)
@@ -40,13 +42,14 @@ public:
     { }
 	~Renderer();
 
+    virtual void SetResolution(const Rectangle& resolution) override;
+
     virtual void Initialize() override;
     virtual void Update(double dt) override;
     virtual void Draw(RenderFrame& frame) override;
 
     virtual PickData Pick(glm::vec2 screenCoord) override;
 
-
 private:
     //----------------------Variables----------------------//
 
@@ -90,11 +93,14 @@ private:
     void InputUpdate(double dt);
     //void PickingPass(RenderQueueCollection& rq);
     //void DrawScreenQuad(GLuint textureToDraw);
+    void setWindowSize(Rectangle size);
+    void updateFramebufferSize();
 
     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-------------------//
+
+    //--------------------ShaderPrograms-------------------//
     ShaderProgram* m_BasicForwardProgram;
     ShaderProgram* m_ExplosionEffectProgram;
 

include/Engine/Rendering/SpriteJob.h

@@ -21,14 +21,15 @@ struct SpriteJob : RenderJob
     SpriteJob(ComponentWrapper cSprite, Camera* camera, glm::mat4 matrix, World* world, glm::vec4 fillColor, float fillPercentage, bool depthSorted, bool isIndicator)
         : RenderJob()
     {
-        Model = ResourceManager::Load<::Model>("Models/Core/UnitQuad.mesh");
+        Model = ResourceManager::Load<::Model>((std::string)cSprite["Model"]);
         ::RawModel::MaterialProperties matProp = Model->MaterialGroups().front();
         TextureID = 0;
 
         DiffuseTexture = CommonFunctions::TryLoadResource<TextureSprite, true>(cSprite["DiffuseTexture"]);
-
         IncandescenceTexture = CommonFunctions::TryLoadResource<TextureSprite, true>(cSprite["GlowMap"]);
 
+        Linear = (bool)cSprite["Linear"];
+
         StartIndex = matProp.material->StartIndex;
         EndIndex = matProp.material->EndIndex;
 		Matrix = matrix;
@@ -48,6 +49,26 @@ struct SpriteJob : RenderJob
 
         FillColor = fillColor;
         FillPercentage = fillPercentage;
+
+        glm::vec3 scale = Transform::AbsoluteScale(world, cSprite.EntityID);
+
+        if((bool)cSprite["KeepRatio"] == true) {
+            if(scale.y >= scale.x) {
+                ScaleY = (scale.x)/(scale.y);
+                ScaleX = 1.f;
+            } else {
+                ScaleY = 1.f;
+                ScaleX = (scale.x)/(scale.y);
+            }
+        } else {
+            if ((bool)cSprite["KeepRatioX"] == true) {
+                ScaleX = scale.x;
+            }
+            if ((bool)cSprite["KeepRatioY"] == true) {
+                ScaleY = scale.y;
+            }
+        }
+
     };
 
     unsigned int TextureID;
@@ -69,6 +90,9 @@ struct SpriteJob : RenderJob
     bool Pickable;
 	bool IsIndicator = false;
     bool BlurBackground = false;
+    float ScaleX = 1;
+    float ScaleY = 1;
+    bool Linear = false;
 
     glm::vec4 FillColor = glm::vec4(0);
     float FillPercentage = 0.0;

include/Engine/Rendering/TextPass.h

@@ -23,6 +23,7 @@ public:
 
 private:
     void renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix);
+	std::string parseColors(std::string text, std::map<int, glm::vec4>& colorChanges, glm::vec4 originalColor);
 
     Font* font;
     GLuint VAO, VBO;

include/Engine/Rendering/Util/GLError.h

@@ -16,7 +16,11 @@ inline bool _GLERROR(const char* info, const char* file, const char* func, unsig
 	return false;
 }
 
+#ifdef DEBUG
 #define GLERROR(function) \
 	_GLERROR(function, __BASE_FILE__, __func__, __LINE__)
+#else
+#define GLERROR(function) false
+#endif
 
 #endif