Merge remote-tracking branch 'origin/master' into RendererBugFixes

Conflicts:
	assets

src/Engine/Network/Client.cpp

@@ -35,6 +35,7 @@ void Client::Connect(std::string address, int port)
     EVENT_SUBSCRIBE_MEMBER(m_EDoubleJump, &Client::OnDoubleJump);
     EVENT_SUBSCRIBE_MEMBER(m_EDashAbility, &Client::OnDashAbility);
     EVENT_SUBSCRIBE_MEMBER(m_ESearchForServers, &Client::OnSearchForServers);
+    EVENT_SUBSCRIBE_MEMBER(m_EConnectRequest, &Client::OnConnectRequest);
     auto config = ResourceManager::Load<ConfigFile>("Config.ini");
     m_Address = address;
     if (address.empty()) {
@@ -180,8 +181,8 @@ void Client::parseTCPConnect(Packet& packet)
     Packet UnreliablePacket(MessageType::Connect, m_SendPacketID);
     // Add player id and other stuff
     packet.WritePrimitive(m_PlayerID);
- //   m_Unreliable.Send(packet);
-  //  LOG_INFO("Sent UDP Connect Server");
+    //   m_Unreliable.Send(packet);
+     //  LOG_INFO("Sent UDP Connect Server");
 }
 
 void Client::parsePlayerConnected(Packet & packet)
@@ -456,12 +457,14 @@ void Client::parseSnapshot(Packet& packet)
 
 void Client::disconnect()
 {
+    removeWorld();
     m_IsConnected = false;
     m_PreviousPacketID = 0;
     m_PacketID = 0;
     Packet packet(MessageType::Disconnect, m_SendPacketID);
     m_Reliable.Send(packet);
     m_Reliable.Disconnect();
+    createMainMenu();
 }
 
 bool Client::OnInputCommand(const Events::InputCommand & e)
@@ -472,7 +475,7 @@ bool Client::OnInputCommand(const Events::InputCommand & e)
 
     if (e.Command == "ConnectToServer") { // Connect for now
         if (e.Value > 0) {
-            m_Reliable.Connect(m_PlayerName, m_Address, m_Port);
+            //m_Reliable.Connect(m_PlayerName, m_Address, m_Port);
         //    m_Unreliable.Connect(m_PlayerName, m_Address, m_Port);
         }
         //LOG_DEBUG("Client::OnInputCommand: Command is %s. Value is %f. PlayerID is %i.", e.Command.c_str(), e.Value, e.PlayerID);
@@ -545,6 +548,23 @@ bool Client::OnDashAbility(const Events::DashAbility& e)
     return true;
 }
 
+
+bool Client::OnConnectRequest(const Events::ConnectRequest& e)
+{
+    removeWorld();
+    if (m_Reliable.Connect(m_PlayerName, e.IP, e.Port)) {
+        // The client sent a successful connect message
+        return true;
+
+    } else {
+        // The client could not send a successful connect message
+        createMainMenu();
+        // Load the main menu again ?
+        return false;
+    }
+    return false;
+}
+
 bool Client::OnSearchForServers(const Events::SearchForServers& e)
 {
     m_SearchingForServers = true;
@@ -671,6 +691,26 @@ void Client::displayServerlist()
     }
 }
 
+
+void Client::removeWorld()
+{
+    std::vector<EntityID> childrenToBeDeleted;
+    auto rootEntites = m_World->GetDirectChildren(EntityID_Invalid);
+    for (auto it = rootEntites.first; it != rootEntites.second; it++) {
+        childrenToBeDeleted.push_back(it->second);
+    }
+    for (int i = 0; i < childrenToBeDeleted.size(); ++i) {
+        m_World->DeleteEntity(childrenToBeDeleted[i]);
+    }
+}
+
+
+void Client::createMainMenu()
+{
+    auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/StartMenu.xml");
+    entityFile->MergeInto(m_World);
+}
+
 bool Client::clientServerMapsHasEntity(EntityID clientEntityID)
 {
     if (m_ClientIDToServerID.find(clientEntityID) != m_ClientIDToServerID.end()) {

src/Engine/Network/Server.cpp

@@ -7,6 +7,8 @@ Server::Server(World* world, EventBroker* eventBroker, int port)
     ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
     snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05f);
     pingIntervalMs = config->Get<float>("Networking.PingIntervalMs", 1000);
+    m_ServerName = config->Get<std::string>("Networking.Name", "Unnamed");
+
     // Subscribe to events
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Server::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &Server::OnPlayerSpawned);
@@ -410,7 +412,7 @@ void Server::parseServerlistRequest(boost::asio::ip::udp::endpoint endpoint)
     Packet packet(MessageType::ServerlistRequest);
     packet.WriteString(m_Reliable.Address());
     packet.WritePrimitive<int>(m_Reliable.Port());
-    packet.WriteString("SERVERNAME");
+    packet.WriteString(m_ServerName);
     packet.WritePrimitive<int>(m_ConnectedPlayers.size());
     m_ServerlistRequest.Send(packet);
 }

src/Engine/Network/TCPClient.cpp

@@ -10,7 +10,7 @@ TCPClient::~TCPClient()
 {
 }
 
-void TCPClient::Connect(std::string playerName, std::string address, int port)
+bool TCPClient::Connect(std::string playerName, std::string address, int port)
 {
     if (m_Socket) {
         if (m_IsConnected) {
@@ -19,6 +19,7 @@ void TCPClient::Connect(std::string playerName, std::string address, int port)
             Send(packet);
             LOG_INFO("Connect message sent again!");
         }
+        return true;
     }
     else if (!m_IsConnected) {
         boost::system::error_code error = boost::asio::error::host_not_found;
@@ -34,11 +35,13 @@ void TCPClient::Connect(std::string playerName, std::string address, int port)
             packet.WriteString(playerName);
             Send(packet);
             LOG_INFO("Connect message sent!");
+            return true;
         }
         // If error
         else {
             m_Socket->close();
             m_Socket = nullptr;
+            return false;
         }
     }
 }

src/Engine/Network/UDPClient.cpp

@@ -10,14 +10,15 @@ UDPClient::~UDPClient()
 { 
 }
 
-void UDPClient::Connect(std::string playerName, std::string address, int port)
+bool UDPClient::Connect(std::string playerName, std::string address, int port)
 {
     if (m_Socket) {
-        return;
+        return false;
     }
     m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address().from_string(address), port);
     m_Socket = boost::shared_ptr<boost::asio::ip::udp::socket>(new boost::asio::ip::udp::socket(m_IOService));
     m_Socket->open(boost::asio::ip::udp::v4());
+    return true;
 }
 
 void UDPClient::Disconnect()

src/Engine/Rendering/BlurHUD.cpp

@@ -10,7 +10,7 @@ BlurHUD::BlurHUD(IRenderer* renderer)
 
 void BlurHUD::InitializeTextures()
 {
-    m_BlackTexture = CommonFunctions::LoadTexture("Textures/Core/Black.png", false);
+    m_BlackTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/Black.png");
     m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
 }
 

src/Engine/Rendering/DrawBloomPass.cpp

@@ -16,7 +16,7 @@ DrawBloomPass::~DrawBloomPass() {
 
 void DrawBloomPass::InitializeTextures()
 {
-    m_BlackTexture = CommonFunctions::LoadTexture("Textures/Core/Black.png", false);
+    m_BlackTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/Black.png");
 }
 
 void DrawBloomPass::ChangeQuality(int quality)

src/Engine/Rendering/DrawFinalPass.cpp

@@ -22,11 +22,11 @@ DrawFinalPass::~DrawFinalPass(){
 
 void DrawFinalPass::InitializeTextures()
 {
-    m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
-    m_BlackTexture = CommonFunctions::LoadTexture("Textures/Core/Black.png", false);
-    m_NeutralNormalTexture = CommonFunctions::LoadTexture("Textures/Core/NeutralNormalMap.png", false);
-    m_GreyTexture = CommonFunctions::LoadTexture("Textures/Core/Grey.png", false);
-    m_ErrorTexture = CommonFunctions::LoadTexture("Textures/Core/ErrorTexture.png", false);
+    m_WhiteTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/White.png");
+    m_BlackTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/Black.png");
+    m_NeutralNormalTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/NeutralNormalMap.png");
+    m_GreyTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/Grey.png");
+    m_ErrorTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/ErrorTexture.png");
 }
 
 void DrawFinalPass::InitializeFrameBuffers()

src/Engine/Rendering/Model.cpp

@@ -10,31 +10,31 @@ Model::Model(std::string fileName)
 		case RawModel::MaterialType::SingleTextures:
 		{
 			RawModel::MaterialSingleTextures* materialSingleTexture = static_cast<RawModel::MaterialSingleTextures*>(materialProperty.material);
-            materialSingleTexture->ColorMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->ColorMap.TexturePath, false);
-            materialSingleTexture->NormalMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->NormalMap.TexturePath, false);
-            materialSingleTexture->SpecularMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->SpecularMap.TexturePath, false);
-            materialSingleTexture->IncandescenceMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->IncandescenceMap.TexturePath, false);
+            materialSingleTexture->ColorMap.Texture = CommonFunctions::TryLoadResource<Texture, false>(materialSingleTexture->ColorMap.TexturePath);
+            materialSingleTexture->NormalMap.Texture = CommonFunctions::TryLoadResource<Texture, false>(materialSingleTexture->NormalMap.TexturePath);
+            materialSingleTexture->SpecularMap.Texture = CommonFunctions::TryLoadResource<Texture, false>(materialSingleTexture->SpecularMap.TexturePath);
+            materialSingleTexture->IncandescenceMap.Texture = CommonFunctions::TryLoadResource<Texture, false>(materialSingleTexture->IncandescenceMap.TexturePath);
 		}
 			break;
 		case RawModel::MaterialType::SplatMapping:
 		{
 			RawModel::MaterialSplatMapping* materialSplatMapping = static_cast<RawModel::MaterialSplatMapping*>(materialProperty.material);
-			materialSplatMapping->SplatMap.Texture = CommonFunctions::LoadTexture(materialSplatMapping->SplatMap.TexturePath, false);
+			materialSplatMapping->SplatMap.Texture = CommonFunctions::TryLoadResource<Texture, false>(materialSplatMapping->SplatMap.TexturePath);
 			for (auto& texture : materialSplatMapping->ColorMaps)
 			{
-				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+				texture.Texture = CommonFunctions::TryLoadResource<Texture, false>(texture.TexturePath);
 			}
 			for (auto& texture : materialSplatMapping->NormalMaps)
 			{
-				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+				texture.Texture = CommonFunctions::TryLoadResource<Texture, false>(texture.TexturePath);
 			}
 			for (auto& texture : materialSplatMapping->SpecularMaps)
 			{
-				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+				texture.Texture = CommonFunctions::TryLoadResource<Texture, false>(texture.TexturePath);
 			}
 			for (auto& texture : materialSplatMapping->IncandescenceMaps)
 			{
-				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+				texture.Texture = CommonFunctions::TryLoadResource<Texture, false>(texture.TexturePath);
 			}
 		}
 			break;

src/Engine/Rendering/Renderer.cpp

@@ -233,8 +233,8 @@ PickData Renderer::Pick(glm::vec2 screenCoord)
 
 void Renderer::InitializeTextures()
 {
-    m_ErrorTexture = CommonFunctions::LoadTexture("Textures/Core/ErrorTexture.png", false);
-    m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
+    m_ErrorTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/ErrorTexture.png");
+    m_WhiteTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/White.png");
 }
 
 

src/Engine/Rendering/SSAOPass.cpp

@@ -4,7 +4,7 @@ SSAOPass::SSAOPass(IRenderer* renderer, ConfigFile* config)
 	: m_Renderer(renderer)
 	, m_Config(config)
 {
-	m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
+	m_WhiteTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/White.png");
 
 	ChangeQuality(m_Config->Get<int>("SSAO.Quality", 0));
 

src/Engine/Rendering/Texture.cpp

@@ -4,18 +4,6 @@ Texture::Texture(std::string path)
 {
     PNG* img = ResourceManager::Load<PNG, true>(path); //TODO: Make this threaded. Catch exeptions in all other load places.
 
-    //PNG image(path);
-
-    //if (img->Width == 0 && img->Height == 0 || img->Format == Image::ImageFormat::Unknown) {
-    //    //image = PNG("Textures/Core/ErrorTexture.png");
-    //    //return; // Temporary fix to remove crash
-
-    //    if (img->Width == 0 && img->Height == 0 || img->Format == Image::ImageFormat::Unknown) {
-    //        LOG_ERROR("Couldn't even load the error texture. This is a dark day indeed.");
-    //        return;
-    //    }
-    //}
-
     this->Width = img->Width;
     this->Height = img->Height;
     this->Data = img->Data;
@@ -29,9 +17,9 @@ Texture::Texture(std::string path)
         format = GL_RGBA;
         break;
     }
-    
-
+   
     // Construct the OpenGL texture
+
     glGenTextures(1, &m_Texture);
     glBindTexture(GL_TEXTURE_2D, m_Texture);
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

src/Engine/Rendering/TextureSprite.cpp

@@ -0,0 +1,11 @@
+#include "Rendering/TextureSprite.h"
+
+TextureSprite::TextureSprite(std::string path)
+    :Texture(path)
+{
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+    GLERROR("Texture load");
+}

src/Engine/Rendering/Util/CommonFunctions.cpp

@@ -1,23 +1,5 @@
 #include "Rendering/Util/CommonFunctions.h"
 
-Texture* CommonFunctions::LoadTexture(std::string path, bool threaded)
-{
-    Texture* img;
-    try {
-        if(threaded) {
-            img = ResourceManager::Load<Texture, true>(path);
-        } else {
-            img = ResourceManager::Load<Texture, false>(path);
-        }
-    } catch (const Resource::StillLoadingException&) {
-        img = ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
-    } catch (const std::exception&) {
-        img = nullptr;
-    }
-
-    return img;
-}
-
 void CommonFunctions::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type)
 {
 	glDeleteTextures(1, texture);