feat: add basic towers rendering

src/render/VertexCache.cpp

@@ -0,0 +1,57 @@
+#include "render/VertexCache.h"
+#include "render/loader/GLLoader.h"
+
+namespace td {
+namespace render {
+
+void VertexCache::addData(std::uint64_t index, std::vector<float> positions, std::vector<float> colors){
+    ElementsIndex positionsIndexes;
+    positionsIndexes.first = m_Positions.end();
+    m_Positions.insert(m_Positions.end(), positions.begin(), positions.end());
+    positionsIndexes.second = m_Positions.end() - 1;
+
+    ElementsIndex colorsIndexes;
+    colorsIndexes.first = m_Colors.end();
+    m_Colors.insert(m_Colors.end(), colors.begin(), colors.end());
+    colorsIndexes.second = m_Colors.end() - 1;
+
+    m_Indexes.insert({index, {positionsIndexes, colorsIndexes}});
+}
+
+void VertexCache::removeData(std::uint64_t index){
+    auto it = m_Indexes.find(index);
+    if(it != m_Indexes.end()){
+        DataIndex indexes = it->second;
+        ElementsIndex positionsIndexes = indexes.first;
+        ElementsIndex colorsIndexes = indexes.second;
+
+        m_Positions.erase(positionsIndexes.first, positionsIndexes.second);
+        m_Colors.erase(colorsIndexes.first, colorsIndexes.second);
+
+        m_Indexes.erase(it);
+    }
+}
+
+void VertexCache::clear(){
+    m_Positions.clear();
+    m_Colors.clear();
+    m_Indexes.clear();
+}
+
+void VertexCache::updateVertexArray(){
+    m_VertexArray = std::make_unique<GL::VertexArray>(m_Colors.size()); // one color per vertex
+
+    GL::VertexBuffer positionsBuffer(m_Positions, 2);
+    positionsBuffer.addVertexAttribPointer(0, 2, 0);
+
+    GL::VertexBuffer colorsBuffer(m_Colors, 1);
+    colorsBuffer.addVertexAttribPointer(1, 1, 0);
+
+    m_VertexArray->bind();
+    m_VertexArray->bindVertexBuffer(positionsBuffer);
+    m_VertexArray->bindVertexBuffer(colorsBuffer);
+    m_VertexArray->unbind();
+}
+
+} // namespace render
+} // namespace td

src/render/WorldRenderer.cpp

@@ -62,6 +62,11 @@ void WorldRenderer::renderMobs() const {
 }
 
 void WorldRenderer::renderTowers() const {
+    if(!m_TowersCache.isEmpty())
+        m_Renderer->renderVAO(m_TowersCache.getVertexArray());
+}
+
+void WorldRenderer::renderTileSelect() const {
     Renderer::Model tileSelectModel;
     tileSelectModel.vao = m_SelectTileVao.get();
     tileSelectModel.positon = { (int)m_CursorPos.x, (int)m_CursorPos.y };
@@ -69,10 +74,6 @@ void WorldRenderer::renderTowers() const {
     m_Renderer->renderModel(tileSelectModel);
 }
 
-void WorldRenderer::renderTileSelect() const {
-
-}
-
 void WorldRenderer::render() {
     if (m_WorldVao == nullptr)
         return;
@@ -151,6 +152,17 @@ void WorldRenderer::detectClick() {
     }
 }
 
+void WorldRenderer::addTower(game::TowerPtr tower){
+    const WorldLoader::RenderData& renderData = WorldLoader::loadTowerModel(tower);
+    m_TowersCache.addData(tower->getID(), renderData.positions, renderData.colors);
+    m_TowersCache.updateVertexArray();
+}
+
+void WorldRenderer::removeTower(game::TowerPtr tower){
+    m_TowersCache.removeData(tower->getID());
+    m_TowersCache.updateVertexArray();
+}
+
 glm::vec2 WorldRenderer::getCursorWorldPos() const {
     ImGuiIO& io = ImGui::GetIO();
     return m_Renderer->getCursorWorldPos({ io.MousePos.x, io.MousePos.y }, Display::getAspectRatio(), m_Zoom, Display::getWindowWidth(), Display::getWindowHeight());

src/render/loader/WorldLoader.cpp

@@ -188,6 +188,40 @@ GL::VertexArray loadTileSelectModel() {
     return tileSelectVao;
 }
 
+RenderData loadTowerModel(game::TowerPtr tower){
+    RenderData renderData;
+
+    float towerX = tower->getX() - 1;
+    float towerDX = tower->getX() + 2;
+
+    float towerY = tower->getY() - 1;
+    float towerDY = tower->getY() + 2;
+    std::vector<float> positions = {
+        towerX, towerY,
+        towerDX, towerY,
+        towerX, towerDY,
+
+        towerDX, towerY,
+        towerX, towerDY,
+        towerDX, towerDY
+    };
+
+    renderData.positions = positions;
+
+    std::uint8_t towerType = static_cast<std::uint8_t>(tower->getType());
+    std::uint8_t r = 10 * towerType + 40, g = 5 * towerType + 30, b = 10 * towerType + 20;
+
+    float colorFloat;
+    int color = r << 24 | g << 16 | b << 8 | 255;
+    memcpy(&colorFloat, &color, sizeof(int));
+
+    std::vector<float> colors(6, colorFloat);
+    renderData.colors = colors;
+
+    return renderData;
+}
+
+
 } // namespace WorldLoader