PrototypeTerrain.h

Go to the documentation of this file.

#pragma once
 
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include <tdme/tdme.h>
#include <tdme/engine/prototype/fwd-tdme.h>
#include <tdme/engine/prototype/Prototype.h>
#include <tdme/engine/prototype/PrototypeTerrainBrush.h>
#include <tdme/engine/Transformations.h>
 
using std::unordered_map;
using std::unordered_set;
using std::vector;
 
using tdme::engine::prototype::Prototype;
using tdme::engine::prototype::PrototypeTerrainBrush;
 
using tdme::engine::Transformations;
 
/**
 * Prototype terrain definition
 * @author Andreas Drewke
 * @version $Id$
 */
class tdme::engine::prototype::PrototypeTerrain final
{
private:
    float width { -1 };
    float depth { -1 };
    vector<float> terrainHeightVector;
    int waterPositionMapIdx { 0 };
    unordered_map<int, float> waterPositionMapsHeight;
    unordered_map<int, unordered_map<int, unordered_set<int>>> waterPositionMaps;
    int foliagePrototypeMapIdx { 0 };
    unordered_map<int, Prototype*> foliageFoliagePrototypeMap;
    vector<unordered_map<int, vector<Transformations>>> foliageMaps;
    vector<PrototypeTerrainBrush*> brushes;
 
public:
 
    /**
     * Public constructor
     */
    inline PrototypeTerrain() {
    }
 
    /**
     * Destructor
     */
    ~PrototypeTerrain() {
        for (auto& foliageFoliagePrototypeMapIt: foliageFoliagePrototypeMap) {
            delete foliageFoliagePrototypeMapIt.second;
        }
        for (auto brush: brushes) delete brush;
    }
 
    /**
     * @return width
     */
    inline float getWidth() const {
        return width;
    }
 
    /**
     * Set width
     * @param width width
     */
    inline void setWidth(float width) {
        this->width = width;
    }
 
    /**
     * @return depth
     */
    inline float getDepth() const {
        return depth;
    }
 
    /**
     * Set depth
     * @param depth depth
     */
    inline void setDepth(float depth) {
        this->depth = depth;
    }
 
    /**
     * @return terrain height vector
     */
    inline vector<float>& getHeightVector() {
        return terrainHeightVector;
    }
 
    /**
     * @return water position maps height
     */
    inline unordered_map<int, float>& getWaterPositionMapsHeight() {
        return waterPositionMapsHeight;
    }
 
    /**
     * @return water position maps
     */
    inline unordered_map<int, unordered_map<int, unordered_set<int>>>& getWaterPositionMaps() {
        return waterPositionMaps;
    }
 
    /**
     * Get water position maps indices
     * @return water position maps indices
     */
    inline vector<int> getWaterPositionMapsIndices() {
        vector<int> waterPositionMapsIndices;
        for (auto waterPositionMapsIt: waterPositionMaps) {
            waterPositionMapsIndices.push_back(waterPositionMapsIt.first);
        }
        return waterPositionMapsIndices;
    }
 
    /**
     * @return allocated water position map idx
     */
    inline int allocateWaterPositionMapIdx() {
        return waterPositionMapIdx++;
    }
 
    /**
     * Get water position map height at given water position map index
     * @param idx water position map index
     * @return water position map height at given water position map index
     */
    inline float getWaterPositionMapHeight(int idx) {
        return waterPositionMapsHeight[idx];
    }
 
    /**
     * Set water position map height at given water position map index
     * @param idx water position map index
     * @param waterHeight waterHeight water height
     */
    inline void setWaterPositionMapHeight(int idx, float waterHeight) {
        waterPositionMapsHeight[idx] = waterHeight;
    }
 
    /**
     * Get water position map at given index
     * @param idx index
     * @return water position map
     */
    inline unordered_map<int, unordered_set<int>>& getWaterPositionMap(int idx) {
        return waterPositionMaps[idx];
    }
 
    /**
     * Remove water position map at given water position map index
     * @param idx water position map index
     */
    inline void removeWaterPositionMap(int idx) {
        waterPositionMapsHeight.erase(idx);
        waterPositionMaps.erase(idx);
    }
 
    /**
     * Get or allocate a foliage prototype index
     * @param prototype prototype
     * @return prototype index
     */
    inline int getFoliagePrototypeIndex(Prototype* prototype) {
        auto foliagePrototypeMapIdx = 0;
        for (auto& foliageFoliagePrototypeMapIt: foliageFoliagePrototypeMap) {
            if (foliageFoliagePrototypeMapIt.first > foliagePrototypeMapIdx) foliagePrototypeMapIdx = foliageFoliagePrototypeMapIt.first;
            if (prototype->getFileName() == foliageFoliagePrototypeMapIt.second->getFileName()) return foliageFoliagePrototypeMapIt.first;
        }
        foliagePrototypeMapIdx++;
        foliageFoliagePrototypeMap[foliagePrototypeMapIdx] = prototype;
        return foliagePrototypeMapIdx;
    }
 
    /**
     * Get foliage prototype indices
     * @return foliage prototype indices
     */
    inline vector<int> getFoliagePrototypeIndices() {
        vector<int> foliagePrototypeIndices;
        for (auto& foliageFoliagePrototypeMapIt: foliageFoliagePrototypeMap) {
            foliagePrototypeIndices.push_back(foliageFoliagePrototypeMapIt.first);
        }
        return foliagePrototypeIndices;
    }
 
    /**
     * Get foliage prototype by given index
     * @param idx protoype index
     * @return prototype or nullptr
     */
    inline Prototype* getFoliagePrototype(int prototypeIdx) {
        auto foliageFoliagePrototypeIt = foliageFoliagePrototypeMap.find(prototypeIdx);
        if (foliageFoliagePrototypeIt == foliageFoliagePrototypeMap.end()) {
            return nullptr;
        }
        return foliageFoliagePrototypeIt->second;
    }
 
    /**
     * @return foliage maps
     */
    inline vector<unordered_map<int, vector<Transformations>>>& getFoliageMaps() {
        return foliageMaps;
    }
 
    /**
     * Get foliage prototype entity ids
     * @param prototypeIdx prototype index
     * @return entity ids
     */
    inline const vector<string> getFoliagePrototypeEntityIds(int prototypeIdx) {
        vector<string> foliagePrototypeEntityIds;
        auto prototypeEntityIdx = 0;
        for (auto& foliageMapPartition: foliageMaps) {
            for (auto& foliageMapPartitionIt: foliageMapPartition) {
                auto& transformationsVector = foliageMapPartition[prototypeIdx];
                if (transformationsVector.empty() == true) continue;
                auto foliagePrototype = getFoliagePrototype(prototypeIdx);
                if (foliagePrototype->isRenderGroups() == false) {
                    for (auto& transformations: transformationsVector) {
                        foliagePrototypeEntityIds.push_back("tdme.foliage." + to_string(prototypeIdx) + "." + to_string(prototypeEntityIdx++));
                    }
                }
            }
        }
        return foliagePrototypeEntityIds;
    }
 
    /**
     * Get foliage prototype entity transformations indexed by entity id
     * @param prototypeIdx prototype index
     * @return transformations indexed by entity id
     */
    inline const map<string, Transformations> getFoliagePrototypeEntityTransformations(int prototypeIdx) {
        map<string, Transformations> foliagePrototypeEntityTransformations;
        auto prototypeEntityIdx = 0;
        for (auto& foliageMapPartition: foliageMaps) {
            auto& transformationsVector = foliageMapPartition[prototypeIdx];
            if (transformationsVector.empty() == true) continue;
            auto foliagePrototype = getFoliagePrototype(prototypeIdx);
            if (foliagePrototype->isRenderGroups() == false) {
                for (auto& transformations: transformationsVector) {
                    foliagePrototypeEntityTransformations["tdme.foliage." + to_string(prototypeIdx) + "." + to_string(prototypeEntityIdx++)] = transformations;
                }
            }
        }
        return foliagePrototypeEntityTransformations;
    }
 
    /**
     * @return prototype terrain brushes
     */
    inline const vector<PrototypeTerrainBrush*>& getBrushes() const {
        return brushes;
    }
 
    /**
     * Get prototype terrain brush
     * @param idx index
     * @return prototype terrain brush prototype
     */
    inline PrototypeTerrainBrush* getBrush(int idx) {
        if (idx < 0 || idx >= brushes.size()) return nullptr;
        return brushes[idx];
    }
 
    /**
     * Add prototype terrain brush
     * @param idx index
     */
    PrototypeTerrainBrush* addBrush() {
        auto brush = new PrototypeTerrainBrush();
        brushes.push_back(brush);
        return brush;
    }
 
    /**
     * Remove prototype terrain brush
     * @param idx index
     */
    bool removeBrush(int idx) {
        if (idx < 0 || idx >= brushes.size()) return false;
        auto brush = brushes[idx];
        brushes.erase(brushes.begin() + idx);
        delete brush;
        return true;
    }
 
};