SpaceTree.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2018 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef GF_SPACE_TREE_H
#define GF_SPACE_TREE_H

#include <functional>
#include <memory>

#include "Portability.h"
#include "Random.h"
#include "Rect.h"
#include "Vector.h"

namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif

  class GF_API SpaceTree {
  public:
    using Callback = std::function<bool(const SpaceTree&)>;

    SpaceTree(const RectI& area);

    const RectI& getArea() const {
      return m_area;
    }

    int getLevel() const {
      return m_level;
    }

    void removeChildren();

    bool splitOnce(Random& random, Vector2i minSize, float maxRatio = 1.5f);

    void splitRecursive(Random& random, int levelMax, Vector2i minSize, Vector2i maxSize, float maxRatio = 1.5f);

    bool isLeaf() const {
      return !m_left && !m_right;
    }

    const SpaceTree *getLeftChild() const {
      return m_left.get();
    }

    SpaceTree *getLeftChild() {
      return m_left.get();
    }

    const SpaceTree *getRightChild() const {
      return m_right.get();
    }

    SpaceTree *getRightChild() {
      return m_right.get();
    }

    const SpaceTree *getFather() const {
      return m_father;
    }

    SpaceTree *getFather() {
      return m_father;
    }

    bool contains(Vector2i position) const;

    const SpaceTree *find(Vector2i position) const;

    bool traversePreOrder(Callback callback) const;

    bool traverseInOrder(Callback callback) const;

    bool traversePostOrder(Callback callback) const;

    bool traverseLevelOrder(Callback callback) const;

    bool traverseInvertedLevelOrder(Callback callback) const;

  private:
    enum class Split {
      None,
      Vertical,
      Horizontal,
    };

    RectI m_area;

    Split m_split;
    int m_position;

    int m_level;

    std::unique_ptr<SpaceTree> m_left;
    std::unique_ptr<SpaceTree> m_right;

    SpaceTree *m_father;
  };

#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // GF_SPACE_TREE_H