BRectBase.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <glm/vec2.hpp>
#include <memory>
#include <optional>
 
namespace sKit {
namespace structure {
 
template <typename Derived>
class BRectBase : public std::enable_shared_from_this<Derived> {
  using SplitFn = std::function<float(unsigned int, glm::vec2)>;
 
 public:
  BRectBase() = default;
 
  auto subdivide(
      unsigned int numLevels,
      glm::vec2 _id = {0, 0},
      SplitFn splitfn = BRectBase<Derived>::splitfn
  ) -> void;
 
  auto getLeaves() -> std::vector<std::shared_ptr<Derived>>;
 
  auto getLeafAt(int x, int y) -> std::optional<std::shared_ptr<Derived>>;
 
  std::shared_ptr<Derived> left, right;
 
  enum class Orientation { VERTICAL, HORIZONTAL };
 
 protected:
  const static float splitfn(unsigned int _level, glm::vec2 _id) {
    return 0.5;
  };
 
  Orientation orientation_ = Orientation::VERTICAL;
  float x_, y_, width_, height_;
  /* vec2 id; */
  glm::vec2 id;
  int levels;
  bool vertical;
};
 
template <typename Derived>
auto BRectBase<Derived>::subdivide(
    unsigned int numLevels,
    glm::vec2 _id,
    SplitFn splitfn
) -> void {
  levels = numLevels;
  id = _id;
 
  if (numLevels == 0) {
    return;
  }
 
  float t = splitfn(levels, id);
  left = std::make_shared<Derived>();
  right = std::make_shared<Derived>();
  if (orientation_ == Orientation::VERTICAL) {
    float x1 = x_;
    float x2 = x_ + width_ * t;
    float w1 = width_ * t;
    float w2 = width_ - width_ * t;
    left->setDimensions(x1, y_, w1, height_);
    left->setOrientation(Orientation::HORIZONTAL);
    left->subdivide(numLevels - 1, {id.x * 2, id.y}, splitfn);
    right->setOrientation(Orientation::HORIZONTAL);
    right->setDimensions(x2, y_, w2, height_);
    right->subdivide(numLevels - 1, {id.x * 2 + 1, id.y}, splitfn);
  } else {
    float y1 = y_;
    float y2 = y_ + height_ * t;
    float h1 = height_ * t;
    float h2 = height_ - height_ * t;
    left->setDimensions(x_, y1, width_, h1);
    left->subdivide(numLevels - 1, {id.x, id.y * 2}, splitfn);
    right->setDimensions(x_, y2, width_, h2);
    right->subdivide(numLevels - 1, {id.x, id.y * 2 + 1}, splitfn);
  }
}
 
template <typename Derived>
auto BRectBase<Derived>::getLeafAt(int x, int y)
    -> std::optional<std::shared_ptr<Derived>> {
  for (auto leaf : getLeaves()) {
    if (leaf->id.x == x && leaf->id.y == y) {
      return leaf;
    }
  }
  return std::nullopt;
}
 
template <typename Derived>
auto BRectBase<Derived>::getLeaves() -> std::vector<std::shared_ptr<Derived>> {
  std::vector<std::shared_ptr<Derived>> leaves;
  if (left && right) {
    for (auto p : left->getLeaves()) {
      leaves.push_back(p);
    }
    for (auto p : right->getLeaves()) {
      leaves.push_back(p);
    }
  } else {
    leaves.push_back(std::static_pointer_cast<Derived>(this->shared_from_this())
    );
  }
  return leaves;
}
 
}  // namespace structure
 
}  // namespace sKit