Un-template the RegionHandler & derivatives.

src/CMakeLists.txt

@@ -107,7 +107,6 @@ set(ZEUS_SRC_FILES
         world/Dimension.cpp
         world/Dimension.h
         world/region/Region.h
-        world/region/RegionHandler.h
         game/entity/world/WireframeEntity.cpp
         game/entity/world/WireframeEntity.h
         def/block/graph/SelectionBox.h
@@ -125,6 +124,6 @@ set(ZEUS_SRC_FILES
         world/region/MapBlock.h def/GameDefs.cpp
         def/GameDefs.h
         api/func/LModuleUtil.cpp
-        api/func/LModuleUtil.h)
+        api/func/LModuleUtil.h world/region/Region.cpp world/region/MapBlock.cpp)
 
 add_library (zeusCore ${ZEUS_SRC_FILES})

src/util/TransPos.h

@@ -45,21 +45,21 @@ namespace TransPos {
 
     //Return a local position vector relative to the respective structure
 
-    static glm::vec3 regionLocalFromVec(glm::vec3 vec) {
+    static inline glm::vec3 regionLocalFromVec(glm::vec3 vec) {
         return localFromGlobal(vec, REGION_BLOCK_LENGTH);
     }
 
-    static glm::vec3 mapBlockLocalFromVec(glm::vec3 vec) {
+    static inline glm::vec3 mapBlockLocalFromVec(glm::vec3 vec) {
         return localFromGlobal(vec, MAPBLOCK_BLOCK_LENGTH);
     }
 
-    static glm::vec3 chunkLocalFromVec(glm::vec3 vec) {
+    static inline glm::vec3 chunkLocalFromVec(glm::vec3 vec) {
         return localFromGlobal(vec, CHUNK_BLOCK_LENGTH);
     }
 
     //Returns the Chunk Position from a pos vector
 
-    static glm::vec3 chunkFromVec(glm::vec3 vec) {
+    static inline glm::vec3 chunkFromVec(glm::vec3 vec) {
         return sectionFromGlobal(vec, CHUNK_BLOCK_LENGTH);
     }
 
@@ -67,17 +67,17 @@ namespace TransPos {
         //Used to get the chunk position from a global coordinate in Dimension
 
         //Retrieve the region pos from a block pos
-        static glm::vec3 regionFromVec(glm::vec3 vec) {
+        static inline glm::vec3 regionFromVec(glm::vec3 vec) {
             return sectionFromGlobal(vec, REGION_CHUNK_LENGTH);
         }
 
         //Retrieve the offset of a mapblock from it's region using a chunk position
-        static glm::vec3 mapBlockOffsetFromRegion(glm::vec3 vec) {
+        static inline glm::vec3 mapBlockOffsetFromRegion(glm::vec3 vec) {
             return sectionFromGlobal(localFromGlobal(vec, REGION_CHUNK_LENGTH), MAPBLOCK_CHUNK_LENGTH);
         }
 
         //Retrieve the offset of a chunk from it's mapblock using a chunk position
-        static glm::vec3 chunkOffsetFromMapBlock(glm::vec3 vec) {
+        static inline glm::vec3 chunkOffsetFromMapBlock(glm::vec3 vec) {
             return localFromGlobal(vec, MAPBLOCK_CHUNK_LENGTH);
         }
     }
@@ -86,11 +86,11 @@ namespace TransPos {
 
     // Used to get indices from various vectors
 
-    static unsigned int mapBlockIndFromVec(glm::vec3 vec) {
+    static inline unsigned int mapBlockIndFromVec(glm::vec3 vec) {
         return (unsigned int)(vec.x + REGION_SIZE * (vec.y + REGION_SIZE * vec.z));
     }
 
-    static unsigned int chunkIndFromVec(glm::vec3 vec) {
+    static inline unsigned int chunkIndFromVec(glm::vec3 vec) {
         return (unsigned int)(vec.x + MAPBLOCK_SIZE * (vec.y + MAPBLOCK_SIZE * vec.z));
     }
 };

src/world/Dimension.cpp

@@ -3,3 +3,45 @@
 //
 
 #include "Dimension.h"
+
+void Dimension::addChunk(glm::vec3 pos, std::shared_ptr<BlockChunk> chunk) {
+
+    glm::vec3 regionPos = TransPos::Dimension::regionFromVec(pos);
+    if (!regions.count(regionPos)) regions.insert({regionPos, new Region(regionPos)});
+    Region* region = regions[regionPos];
+
+    glm::vec3 mapBlockPos = TransPos::Dimension::mapBlockOffsetFromRegion(pos);
+    unsigned int mapBlockInd = TransPos::mapBlockIndFromVec(mapBlockPos);
+    if ((*region)[mapBlockInd] == nullptr) region->set(mapBlockInd, new MapBlock(mapBlockPos));
+    MapBlock* mapBlock = (*region)[mapBlockInd];
+
+    glm::vec3 chunkPos = TransPos::Dimension::chunkOffsetFromMapBlock(pos);
+    unsigned int chunkInd = TransPos::chunkIndFromVec(chunkPos);
+    mapBlock->set(chunkInd, std::move(chunk));
+}
+
+std::shared_ptr<BlockChunk> Dimension::getChunk(glm::vec3 pos) {
+
+    glm::vec3 regionPos = TransPos::Dimension::regionFromVec(pos);
+    if (!regions.count(regionPos)) return nullptr;
+    Region* region = regions[regionPos];
+
+    glm::vec3 mapBlockPos = TransPos::Dimension::mapBlockOffsetFromRegion(pos);
+    unsigned int mapBlockInd = TransPos::mapBlockIndFromVec(mapBlockPos);
+    if ((*region)[mapBlockInd] == nullptr) return nullptr;
+    MapBlock* mapBlock = (*region)[mapBlockInd];
+
+    glm::vec3 chunkPos = TransPos::Dimension::chunkOffsetFromMapBlock(pos);
+    unsigned int chunkInd = TransPos::chunkIndFromVec(chunkPos);
+    return (*mapBlock)[chunkInd];
+}
+
+Region* Dimension::getRegion(glm::vec3 pos) {
+    return regions[pos];
+}
+
+Dimension::~Dimension() {
+    for (const auto &region : regions) {
+        delete region.second;
+    }
+}

src/world/Dimension.h

@@ -5,14 +5,24 @@
 #ifndef ZEUS_DIMENSION_H
 #define ZEUS_DIMENSION_H
 
-#include <unordered_map>
+
 #include <vec3.hpp>
-#include "../util/Vec.h"
+#include <unordered_map>
 #include "region/Region.h"
-#include "region/RegionHandler.h"
+#include "../util/Vec.h"
 
-class Dimension : public RegionHandler<BlockChunk> {
+class Dimension {
+public:
+    Dimension() = default;
 
+    void addChunk(glm::vec3 pos, std::shared_ptr<BlockChunk> chunk);
+    std::shared_ptr<BlockChunk> getChunk(glm::vec3 pos);
+
+    Region* getRegion(glm::vec3 pos);
+
+    ~Dimension();
+private:
+    std::unordered_map<glm::vec3, Region*, VecUtils::compareFunc> regions;
 };
 
 

src/world/region/MapBlock.cpp

@@ -0,0 +1,21 @@
+//
+// Created by aurailus on 22/04/19.
+//
+
+#include "MapBlock.h"
+
+MapBlock::MapBlock(glm::vec3 pos) {
+    for (int i = 0; i < arrayLength; i++) {
+        blockChunks[i] = nullptr;
+    }
+
+    this->pos = pos;
+}
+
+std::shared_ptr<BlockChunk> MapBlock::operator[](int index) {
+    return blockChunks[index];
+}
+
+void MapBlock::set(int index, std::shared_ptr<BlockChunk> chunk) {
+    blockChunks[index] = std::move(chunk);
+}

src/world/region/MapBlock.h

@@ -11,39 +11,19 @@
 #include "../../util/TransPos.h"
 #include "../chunk/BlockChunk.h"
 
-template <class C>
 class MapBlock {
 public:
     explicit MapBlock(glm::vec3 pos);
 
-    std::shared_ptr<C> operator[](int index);
-    void set(int index, std::shared_ptr<C> chunk);
+    std::shared_ptr<BlockChunk> operator[](int index);
+    void set(int index, std::shared_ptr<BlockChunk> chunk);
 
     ~MapBlock() = default;
 private:
     glm::vec3 pos {};
 
     const static int arrayLength = TransPos::MAPBLOCK_SIZE * TransPos::MAPBLOCK_SIZE * TransPos::MAPBLOCK_SIZE;
-    std::array<std::shared_ptr<C>, arrayLength> blockChunks;
+    std::array<std::shared_ptr<BlockChunk>, arrayLength> blockChunks;
 };
 
-template<class C>
-MapBlock<C>::MapBlock(glm::vec3 pos) {
-    for (int i = 0; i < arrayLength; i++) {
-        blockChunks[i] = nullptr;
-    }
-
-    this->pos = pos;
-}
-
-template<class C>
-std::shared_ptr<C> MapBlock<C>::operator[](int index) {
-    return blockChunks[index];
-}
-
-template<class C>
-void MapBlock<C>::set(int index, std::shared_ptr<C> chunk) {
-    blockChunks[index] = chunk;
-}
-
 #endif //ZEUS_MAPBLOCK_H

src/world/region/Region.cpp

@@ -0,0 +1,27 @@
+//
+// Created by aurailus on 22/04/19.
+//
+
+#include "Region.h"
+
+Region::Region(glm::vec3 pos) {
+    for (int i = 0; i < arrayLength; i++) {
+        mapBlocks[i] = nullptr;
+    }
+
+    this->pos = pos;
+}
+
+MapBlock *Region::operator[](int index) {
+    return mapBlocks[index];
+}
+
+void Region::set(int index, MapBlock *block) {
+    mapBlocks[index] = block;
+}
+
+Region::~Region() {
+    for (int i = 0; i < arrayLength; i++) {
+        delete mapBlocks[i];
+    }
+}

src/world/region/Region.h

@@ -11,47 +11,19 @@
 #include "MapBlock.h"
 #include "../../util/TransPos.h"
 
-template <class C>
 class Region {
 public:
     explicit Region(glm::vec3 pos);
 
-    MapBlock<C>* operator[](int index);
-    void set(int index, MapBlock<C>* block);
+    MapBlock* operator[](int index);
+    void set(int index, MapBlock* block);
 
     ~Region();
 private:
     glm::vec3 pos {};
 
     const static int arrayLength = TransPos::REGION_SIZE * TransPos::REGION_SIZE * TransPos::REGION_SIZE;
-    std::array<MapBlock<C>*, arrayLength> mapBlocks;
+    std::array<MapBlock*, arrayLength> mapBlocks {};
 };
 
-template<class C>
-Region<C>::Region(glm::vec3 pos) {
-    for (int i = 0; i < arrayLength; i++) {
-        mapBlocks[i] = nullptr;
-    }
-
-    this->pos = pos;
-}
-
-template<class C>
-MapBlock<C> *Region<C>::operator[](int index) {
-    return mapBlocks[index];
-}
-
-template<class C>
-void Region<C>::set(int index, MapBlock<C> *block) {
-    mapBlocks[index] = block;
-}
-
-template<class C>
-Region<C>::~Region() {
-    for (int i = 0; i < arrayLength; i++) {
-        delete mapBlocks[i];
-    }
-}
-
-
 #endif //ZEUS_REGION_H

src/world/region/RegionHandler.h

@@ -1,30 +0,0 @@
-//
-// Created by aurailus on 07/04/19.
-//
-
-#ifndef ZEUS_REGIONHANDLER_H
-#define ZEUS_REGIONHANDLER_H
-
-#include <vec3.hpp>
-#include <unordered_map>
-#include "Region.h"
-#include "../../util/Vec.h"
-
-template <class T>
-class RegionHandler {
-public:
-    RegionHandler() = default;
-
-    void addChunk(glm::vec3 pos, std::shared_ptr<T> chunk);
-    std::shared_ptr<T> getChunk(glm::vec3 pos);
-
-    Region<T>* getRegion(glm::vec3 pos);
-
-    ~RegionHandler();
-private:
-    std::unordered_map<glm::vec3, Region<T>*, VecUtils::compareFunc> regions;
-};
-
-#include "RegionHandler.inl"
-
-#endif //ZEUS_REGIONHANDLER_H

src/world/region/RegionHandler.inl

@@ -1,45 +0,0 @@
-template <class T>
-void RegionHandler<T>::addChunk(glm::vec3 pos, std::shared_ptr<T> chunk) {
-
-    glm::vec3 regionPos = TransPos::Dimension::regionFromVec(pos);
-    if (!regions.count(regionPos)) regions.insert({regionPos, new Region<T>(regionPos)});
-    Region<T>* region = regions[regionPos];
-
-    glm::vec3 mapBlockPos = TransPos::Dimension::mapBlockOffsetFromRegion(pos);
-    unsigned int mapBlockInd = TransPos::mapBlockIndFromVec(mapBlockPos);
-    if ((*region)[mapBlockInd] == nullptr) region->set(mapBlockInd, new MapBlock<T>(mapBlockPos));
-    MapBlock<T>* mapBlock = (*region)[mapBlockInd];
-
-    glm::vec3 chunkPos = TransPos::Dimension::chunkOffsetFromMapBlock(pos);
-    unsigned int chunkInd = TransPos::chunkIndFromVec(chunkPos);
-    mapBlock->set(chunkInd, chunk);
-}
-
-template <class T>
-std::shared_ptr<T> RegionHandler<T>::getChunk(glm::vec3 pos) {
-
-    glm::vec3 regionPos = TransPos::Dimension::regionFromVec(pos);
-    if (!regions.count(regionPos)) return nullptr;
-    Region<T>* region = regions[regionPos];
-
-    glm::vec3 mapBlockPos = TransPos::Dimension::mapBlockOffsetFromRegion(pos);
-    unsigned int mapBlockInd = TransPos::mapBlockIndFromVec(mapBlockPos);
-    if ((*region)[mapBlockInd] == nullptr) return nullptr;
-    MapBlock<T>* mapBlock = (*region)[mapBlockInd];
-
-    glm::vec3 chunkPos = TransPos::Dimension::chunkOffsetFromMapBlock(pos);
-    unsigned int chunkInd = TransPos::chunkIndFromVec(chunkPos);
-    return (*mapBlock)[chunkInd];
-}
-
-template <class T>
-Region<T>* RegionHandler<T>::getRegion(glm::vec3 pos) {
-    return regions[pos];
-}
-
-template <class T>
-RegionHandler<T>::~RegionHandler() {
-    for (std::pair<glm::vec3, Region<T>*> region : regions) {
-        delete region.second;
-    }
-}