NavMeshConfig.h

Go to the documentation of this file.

/*
   Copyright (c) 2018 DIVIDE-Studio
   Copyright (c) 2009 Ionut Cava
 
   This file is part of DIVIDE Framework.
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software
   and associated documentation files (the "Software"), to deal in the Software
   without restriction,
   including without limitation the rights to use, copy, modify, merge, publish,
   distribute, sublicense,
   and/or sell copies of the Software, and to permit persons to whom the
   Software is furnished to do so,
   subject to the following conditions:
 
   The above copyright notice and this permission notice shall be included in
   all copies or substantial portions of the Software.
 
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   IMPLIED,
   INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
   PARTICULAR PURPOSE AND NONINFRINGEMENT.
   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
   DAMAGES OR OTHER LIABILITY,
   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
   IN CONNECTION WITH THE SOFTWARE
   OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 */
 
#pragma once
#ifndef DVD_NAV_MESH_CONFIG_H_
#define DVD_NAV_MESH_CONFIG_H_
 
#include "NavMeshDefines.h"
 
/*http://www.ogre3d.org/forums/viewtopic.php?f=11&t=69781&sid=2439989b4c0208780a353e4c90f9864b
 */
 
namespace Divide {
namespace AI {
 
class NavigationMeshConfig {
   public:
    NavigationMeshConfig()
    {
        eval();
    }
 
    /*****************
      * Rasterization
     *****************/
    void setCellSize(const F32 cellSize) {
        this->_cellSize = cellSize;
        eval();
    }
 
    void setCellHeight(const F32 cellHeight) {
        this->_cellHeight = cellHeight;
        eval();
    }
 
    void setTileSize(const I32 tileSize) noexcept { 
        this->_tileSize = tileSize;
    }
 
    /*****************
      * Agent
     *****************/
    void setAgentHeight(const F32 agentHeight) {
        this->_agentHeight = agentHeight;
        eval();
    }
 
    void setAgentRadius(const F32 agentRadius) {
        this->_agentRadius = agentRadius;
        eval();
    }
 
    void setAgentMaxClimb(const F32 agentMaxClimb) {
        this->_agentMaxClimb = agentMaxClimb;
        eval();
    }
 
    void setAgentMaxSlope(const F32 agentMaxSlope) noexcept {
        this->_agentMaxSlope = agentMaxSlope;
    }
 
    /*****************
      * Region
     *****************/
    void setRegionMinSize(const I32 regionMinSize) {
        this->_regionMinSize = regionMinSize;
        eval();
    }
 
    void setRegionMergeSize(const I32 regionMergeSize) {
        this->_regionMergeSize = regionMergeSize;
        eval();
    }
 
    /*****************
      * Polygonization
     *****************/
    void setEdgeMaxLen(const I32 edgeMaxLength) {
        this->_edgeMaxLen = edgeMaxLength;
        eval();
    }
 
    void setEdgeMaxError(const F32 edgeMaxError) noexcept {
        this->_edgeMaxError = edgeMaxError;
    }
 
    void setVertsPerPoly(const I32 vertsPerPoly) noexcept {
        this->_vertsPerPoly = vertsPerPoly;
    }
 
    /*****************
      * Detail mesh
     *****************/
    void setDetailSampleDist(const F32 detailSampleDist) {
        this->_detailSampleDist = detailSampleDist;
        eval();
    }
 
    void setDetailSampleMaxError(const F32 detailSampleMaxError) {
        this->_detailSampleMaxError = detailSampleMaxError;
        eval();
    }
 
    void setKeepInterResults(const bool keepInterResults) noexcept {
        this->_keepInterResults = keepInterResults;
    }
 
    /*********************************************************************
      * Override derived parameters (params set in the eval function)
     *********************************************************************/
 
    void base_setWalkableHeight(const I32 walkableHeight) noexcept {
        this->_walkableHeight = walkableHeight;
    }
 
    void base_setWalkableClimb(const I32 walkableClimb) noexcept {
        this->_walkableClimb = walkableClimb;
    }
 
    void base_setWalkableRadius(const I32 walkableRadius) noexcept {
        this->_walkableRadius = walkableRadius;
    }
 
    void base_setMaxEdgeLen(const I32 maxEdgeLen) noexcept {
        this->_maxEdgeLen = maxEdgeLen;
    }
 
    void base_setMinRegionArea(const I32 minRegionArea) noexcept {
        this->_minRegionArea = minRegionArea;
    }
 
    void base_setMergeRegionArea(const I32 mergeRegionArea) noexcept {
        this->_mergeRegionArea = mergeRegionArea;
    }
 
    void base_setDetailSampleDist(const F32 detailSampleDist) noexcept {
        this->_base_detailSampleDist = detailSampleDist;
    }
 
    void base_setDetailSampleMaxError(const F32 detailSampleMaxError) noexcept {
        this->_base_detailSampleMaxError = detailSampleMaxError;
    }
 
    [[nodiscard]] F32 getCellSize()             const noexcept { return _cellSize; }
    [[nodiscard]] F32 getCellHeight()           const noexcept { return _cellHeight; }
    [[nodiscard]] I32 getTileSize()             const noexcept { return _tileSize; }
    [[nodiscard]] F32 getAgentMaxSlope()        const noexcept { return _agentMaxSlope; }
    [[nodiscard]] F32 getAgentHeight()          const noexcept { return _agentHeight; }
    [[nodiscard]] F32 getAgentMaxClimb()        const noexcept { return _agentMaxClimb; }
    [[nodiscard]] F32 getAgentRadius()          const noexcept { return _agentRadius; }
    [[nodiscard]] I32 getEdgeMaxLen()           const noexcept { return _edgeMaxLen; }
    [[nodiscard]] F32 getEdgeMaxError()         const noexcept { return _edgeMaxError; }
    [[nodiscard]] I32 getRegionMinSize()        const noexcept { return _regionMinSize; }
    [[nodiscard]] I32 getRegionMergeSize()      const noexcept { return _regionMergeSize; }
    [[nodiscard]] I32 getVertsPerPoly()         const noexcept { return _vertsPerPoly; }
    [[nodiscard]] F32 getDetailSampleDist()     const noexcept { return _detailSampleDist; }
    [[nodiscard]] F32 getDetailSampleMaxError() const noexcept { return _detailSampleMaxError; }
    [[nodiscard]] bool getKeepInterResults()    const noexcept { return _keepInterResults; }
 
    [[nodiscard]] I32 base_getWalkableHeight()       const noexcept { return _walkableHeight; }
    [[nodiscard]] I32 base_getWalkableClimb()        const noexcept { return _walkableClimb; }
    [[nodiscard]] I32 base_getWalkableRadius()       const noexcept { return _walkableRadius; }
    [[nodiscard]] I32 base_getMaxEdgeLen()           const noexcept { return _maxEdgeLen; }
    [[nodiscard]] I32 base_getMinRegionArea()        const noexcept { return _minRegionArea; }
    [[nodiscard]] I32 base_getMergeRegionArea()      const noexcept { return _mergeRegionArea; }
    [[nodiscard]] I32 base_getDetailSampleDist()     const noexcept { return to_I32(_base_detailSampleDist); }
    [[nodiscard]] I32 base_getDetailSampleMaxError() const noexcept { return to_I32(_base_detailSampleMaxError); }
 
   private:
    void eval() {
        _walkableHeight = to_I32(ceilf(_agentHeight / _cellHeight));
        _walkableClimb = to_I32(floorf(_agentMaxClimb / _cellHeight));
        _walkableRadius = to_I32(ceilf(_agentRadius / _cellSize));
        _maxEdgeLen = to_I32(_edgeMaxLen / _cellSize);
        _minRegionArea = to_I32(rcSqr(_regionMinSize));  // Note: area = size*size
        _mergeRegionArea = to_I32(rcSqr(_regionMergeSize));  // Note: area = size*size
        _base_detailSampleDist = _detailSampleDist < 0.9f ? 0 : _cellSize * _detailSampleDist;
        _base_detailSampleMaxError = _cellHeight * _detailSampleMaxError;
    }
 
    I32 _tileSize = 48;
 
    F32 _cellSize = 0.3f;
 
    F32 _cellHeight = 0.2f;
 
    F32 _agentMaxSlope = 20;
 
    F32 _agentHeight = 2.5f;
 
    F32 _agentMaxClimb = 1;
 
    F32 _agentRadius = 0.5f;
 
    I32 _edgeMaxLen = 12;
 
    F32 _edgeMaxError = 1.3f;
 
    I32 _regionMinSize = 50;
 
    I32 _regionMergeSize = 20;
 
    I32 _vertsPerPoly = DT_VERTS_PER_POLYGON;
 
    F32 _detailSampleDist = 6;
 
    F32 _detailSampleMaxError = 1;
 
    bool _keepInterResults = false;
 
    I32 _walkableHeight;
 
    I32 _walkableClimb;
 
    I32 _walkableRadius;
 
    I32 _maxEdgeLen;
 
    I32 _minRegionArea;
 
    I32 _mergeRegionArea;
 
    F32 _base_detailSampleDist;
 
    F32 _base_detailSampleMaxError;
};
 
}  // namespace AI
}  // namespace Divide
 
#endif //DVD_NAV_MESH_CONFIG_H_