change WorldRenderer to class

include/game/BaseGame.h

@@ -10,7 +10,8 @@ namespace game {
 enum class GameState : std::uint8_t{
     Lobby,
     Game,
-    EndGame
+    EndGame,
+    Disconnected,
 };
 
 typedef std::map<std::uint8_t, Player> PlayerList;

include/game/client/Client.h

@@ -22,6 +22,8 @@ public:
 
     void tick(std::uint64_t delta);
 
+    void render();
+
     void connect(const std::string& address, std::uint16_t port);
     void closeConnection();
 

include/game/client/ClientGame.h

@@ -3,6 +3,7 @@
 #include "game/BaseGame.h"
 #include "protocol/PacketHandler.h"
 #include "WorldClient.h"
+#include "render/WorldRenderer.h"
 
 namespace td {
 namespace client {
@@ -13,12 +14,15 @@ private:
     std::uint32_t m_LobbyTime = 0;
     game::Player* m_Player = nullptr;
     client::WorldClient m_WorldClient{this};
+    render::WorldRenderer m_WorldRenderer{&m_WorldClient};
 public:
     ClientGame(protocol::PacketDispatcher* dispatcher);
     virtual ~ClientGame();
 
     virtual void tick(std::uint64_t delta);
 
+    void renderWorld();
+
     std::uint32_t getLobbyTime() const{return m_LobbyTime;}
     const game::Player* getPlayer() const{return m_Player;}
 
@@ -30,6 +34,8 @@ public:
     virtual void HandlePacket(protocol::UpdateGameStatePacket* packet);
     virtual void HandlePacket(protocol::UpdateLobbyTimePacket* packet);
     virtual void HandlePacket(protocol::UpdateMoneyPacket* packet);
+    virtual void HandlePacket(protocol::DisconnectPacket* packet);
+    virtual void HandlePacket(protocol::WorldDataPacket* packet);
 };
 
 } // namespace client

include/render/WorldRenderer.h

@@ -1,23 +1,39 @@
 #pragma once
 
 #include "game/World.h"
+#include "render/loader/GLLoader.h"
+
+#include <glm/glm.hpp>
 
 namespace td {
 namespace render {
 
-namespace WorldRenderer{
+class WorldRenderer{
+private:
+    game::World* m_World;
+    std::unique_ptr<GL::VAO> m_WorldVao, m_MobVao;
+    glm::vec2 m_CamPos;
+    float m_Zoom = 1;
+    float m_CamSensibility = 1;
+public:
+    WorldRenderer(game::World* world);
+    ~WorldRenderer();
 
-void init(const game::World* world);
+    void loadModels();
-void update();
-void render();
-void destroy();
 
-void moveCam(float relativeX, float relativeY, float aspectRatio);
+    void update();
-void changeZoom(float zoom);
+    void render() const;
-void click(int mouseX, int mouseY);
 
-} // namespace WorldRenderer
+    void setCamPos(float camX, float camY);
 
+    void moveCam(float relativeX, float relativeY, float aspectRatio);
+    void changeZoom(float zoom);
+    void click(int mouseX, int mouseY);
+private:
+    void renderWorld() const;
+    void renderTowers() const;
+    void renderMobs() const;
+};
 
 } // namespace render
 } // namespace td

src/game/client/Client.cpp

@@ -42,6 +42,9 @@ void Client::tick(std::uint64_t delta){
     }
 }
 
+void Client::render(){
+    m_Game.renderWorld();
+}
 
 } // namespace client
 } // namespace td

src/game/client/ClientConnexion.cpp

@@ -42,7 +42,6 @@ bool ClientConnexion::updateSocket(){
 void ClientConnexion::HandlePacket(protocol::DisconnectPacket* packet){
     m_DisconnectReason = packet->getReason();
     closeConnection();
-    render::WorldRenderer::destroy();
 }
 
 } // namespace client

src/game/client/ClientGame.cpp

@@ -16,6 +16,8 @@ ClientGame::ClientGame(protocol::PacketDispatcher* dispatcher): protocol::Packet
     GetDispatcher()->RegisterHandler(protocol::PacketType::UpdateLobbyTime, this);
     GetDispatcher()->RegisterHandler(protocol::PacketType::UpdateGameState, this);
     GetDispatcher()->RegisterHandler(protocol::PacketType::UpdateMoney, this);
+    GetDispatcher()->RegisterHandler(protocol::PacketType::Disconnect, this);
+    GetDispatcher()->RegisterHandler(protocol::PacketType::WorldData, this);
 }
 
 ClientGame::~ClientGame(){
@@ -24,6 +26,7 @@ ClientGame::~ClientGame(){
 
 void ClientGame::tick(std::uint64_t delta){
     game::Game::tick(delta);
+    m_WorldRenderer.update();
     if (m_GameState == game::GameState::Lobby && m_Players.size() >= 2){
         m_LobbyTime -= delta;
     }
@@ -90,5 +93,22 @@ void ClientGame::HandlePacket(protocol::UpdateMoneyPacket* packet){
     m_Player->setGold(packet->getGold());
 }
 
+void ClientGame::HandlePacket(protocol::DisconnectPacket* packet){
+    m_GameState = game::GameState::Disconnected;
+}
+
+void ClientGame::HandlePacket(protocol::WorldDataPacket* packet){
+    m_WorldRenderer.loadModels();
+    // set cam pos to player spawn
+    const game::Spawn& spawn = m_World->getTeam(m_Player->getTeamColor()).getSpawn();
+    m_WorldRenderer.setCamPos(spawn.x, spawn.y);
+}
+
+void ClientGame::renderWorld(){
+    if(m_GameState == game::GameState::Game || m_GameState == game::GameState::EndGame){
+        m_WorldRenderer.render();
+    }
+}
+
 } // namespace client
 } // namespace td

src/game/client/WorldClient.cpp

@@ -18,7 +18,6 @@ void WorldClient::HandlePacket(protocol::WorldBeginDataPacket* packet){
 
 void WorldClient::HandlePacket(protocol::WorldDataPacket* packet){
     loadMap(packet);
-    render::WorldRenderer::init(this);
 }
 
 void WorldClient::HandlePacket(protocol::SpawnMobPacket* packet){

src/game/server/ServerGame.cpp

@@ -14,6 +14,8 @@ void ServerGame::tick(std::uint64_t delta){
 }
 
 void ServerGame::startGame(){
+    balanceTeams();
+
     protocol::WorldBeginDataPacket headerMapData(m_World);
     m_Server->broadcastPacket(&headerMapData);
     
@@ -22,8 +24,6 @@ void ServerGame::startGame(){
 
     m_GameState = game::GameState::Game;
 
-    balanceTeams();
-
     m_ServerWorld.spawnMobs(game::MobType::Zombie, 1, 0, 12);
 }
 

src/render/WorldRenderer.cpp

@@ -9,29 +9,18 @@
 namespace td {
 namespace render {
 
-namespace WorldRenderer{
+void WorldRenderer::loadModels(){
-
-static std::unique_ptr<GL::VAO> worldVAO;
-static const game::World* worldPtr = nullptr;
-
-static glm::vec2 camPos{13.5, 13.5};//{60, -10};
-static float zoom = 1;
-
-static const float camSensibility = 1;
-
-static std::unique_ptr<GL::VAO> mobVAO;
-
-void init(const game::World* world){
     std::cout << "World Created !\n";
-    worldVAO = std::make_unique<GL::VAO>(std::move(WorldLoader::loadWorldModel(world)));
+    m_WorldVao = std::make_unique<GL::VAO>(std::move(WorldLoader::loadWorldModel(m_World)));
-    mobVAO = std::make_unique<GL::VAO>(std::move(WorldLoader::loadMobModel()));
+    m_MobVao = std::make_unique<GL::VAO>(std::move(WorldLoader::loadMobModel()));
-    std::cout << "Vertex Count : " << worldVAO->getVertexCount() << std::endl;
+    std::cout << "Vertex Count : " << m_WorldVao->getVertexCount() << std::endl;
-    Renderer::setCamPos(camPos);
-    worldPtr = world;
 }
 
-void update(){
+WorldRenderer::WorldRenderer(game::World* world) : m_World(world){
-    if(worldVAO == nullptr)
+}
+
+void WorldRenderer::update(){
+    if(m_WorldVao == nullptr)
         return;
     ImGuiIO& io = ImGui::GetIO();
     if(io.MouseDown[0] && !ImGui::IsAnyItemActive()){
@@ -45,68 +34,66 @@ void update(){
     }
 }
 
-void renderWorld(){
+void WorldRenderer::renderWorld() const{
-    Renderer::renderVAO(*worldVAO);
+    Renderer::renderVAO(*m_WorldVao);
 }
 
-void renderMobs(){
+void WorldRenderer::renderMobs() const{
-    for(game::MobPtr mob : worldPtr->getMobList()){
+    for(game::MobPtr mob : m_World->getMobList()){
         Renderer::Model model;
-        model.vao = mobVAO.get();
+        model.vao = m_MobVao.get();
         model.positon = {mob->getX(), mob->getY()};
         Renderer::renderModel(model);
     }
 }
 
-void renderTowers(){
+void WorldRenderer::renderTowers() const{
 
 }
 
-void render(){
+void WorldRenderer::render() const{
-    if(worldVAO == nullptr)
+    if(m_WorldVao == nullptr)
         return;
     renderWorld();
     renderMobs();
     renderTowers();
 }
 
-void destroy(){
+WorldRenderer::~WorldRenderer(){
-    if(worldVAO == nullptr)
+    
-        return;
-    worldVAO.reset();
-    worldPtr = nullptr;
 }
 
-void moveCam(float relativeX, float relativeY, float aspectRatio){
+void WorldRenderer::moveCam(float relativeX, float relativeY, float aspectRatio){
-    if(worldVAO == nullptr)
+    if(m_WorldVao == nullptr)
         return;
-    float movementX = -relativeX / zoom * aspectRatio;
+    float movementX = -relativeX / m_Zoom * aspectRatio;
-    float movementY = relativeY / zoom;
+    float movementY = relativeY / m_Zoom;
     Renderer::setCamMovement({movementX, movementY});
 }
 
-void changeZoom(float zoomStep){
+void WorldRenderer::changeZoom(float zoomStep){
-    if(worldVAO == nullptr)
+    if(m_WorldVao == nullptr)
         return;
     static float sensibility = 1.5f;
     if (zoomStep < 0){
-        zoom /= -zoomStep * sensibility;
+        m_Zoom /= -zoomStep * sensibility;
     }
     else{
-        zoom *= zoomStep * sensibility;
+        m_Zoom *= zoomStep * sensibility;
     }
-    Renderer::setZoom(zoom);
+    Renderer::setZoom(m_Zoom);
     Renderer::setCamMovement({});
 }
 
-void click(int mouseX, int mouseY){
+void WorldRenderer::click(int mouseX, int mouseY){
-    if(worldVAO == nullptr)
+    if(m_WorldVao == nullptr)
         return;
 }
 
-
+void WorldRenderer::setCamPos(float camX, float camY){
-} // namespace WorldRenderer
+    m_CamPos = {camX, camY};
-
+    Renderer::setCamPos(m_CamPos);
+}
 
 } // namespace render
 } // namespace td

src/render/gui/TowerGui.cpp

@@ -301,6 +301,7 @@ void tick(){
 
 void render(){
     tick();
+    client.render();
     beginFrame();
     if (client.isConnected())
         renderGame();

src/window/Display.cpp

@@ -37,11 +37,6 @@ void keyboard_event(GLFWwindow* window, int key, int scancode, int actions, int
 void mouseCursorEvent(GLFWwindow* window, double xPos, double yPos){
     static double lastX = xPos;
     static double lastY = yPos;
-    if(isMouseDown(0)){
-        const float relativeX = (float) (xPos - lastX) / (float) lastWidth * 2;
-		const float relativeY = (float) (yPos - lastY) / (float) lastHeight * 2;
-        td::render::WorldRenderer::moveCam(relativeX, relativeY, aspectRatio);
-    }
     lastX = xPos;
     lastY = yPos;
 }
@@ -54,7 +49,7 @@ void windowResizeEvent(GLFWwindow* window, int width, int height){
 }
 
 void mouseScroll(GLFWwindow* window, double x, double y){
-    td::render::WorldRenderer::changeZoom(y);
+    
 }
 
 void registerCallbacks(){
@@ -84,7 +79,6 @@ void create() {
 
 void render() {
 	td::render::Renderer::prepare();
-	td::render::WorldRenderer::render();
     TowerGui::render();
 }
 
@@ -99,7 +93,6 @@ void update() {
 
 void destroy() {
     td::render::Renderer::destroy();
-    td::render::WorldRenderer::destroy();
     TowerGui::destroy();
     glfwDestroyWindow(window);
 	window = NULL;
@@ -108,7 +101,6 @@ void destroy() {
 
 void pollEvents() {
     glfwPollEvents();
-    td::render::WorldRenderer::update();
 }
 
 bool isCloseRequested() {