heightmap.h

Go to the documentation of this file.

#pragma once
 
#include "coordinate.h"
#include <cstdint>
#include <memory>
#include <vector>
 
namespace mcpp {
struct HeightMap {
private:
  Coordinate2D _base_pt;
  uint16_t _x_len;
  uint16_t _z_len;
  std::unique_ptr<int16_t[]> _raw_heights;
 
public:
  // Constructors and assignment
  HeightMap(const Coordinate2D& loc1, const Coordinate2D& loc2,
            const std::vector<int16_t>& heights);
  ~HeightMap() = default;
 
  HeightMap(const HeightMap& other)
      : _base_pt(other._base_pt), _x_len(other._x_len), _z_len(other._z_len) {
    size_t size = _x_len * _z_len;
    // Allocate memory and copy the heights
    _raw_heights.reset(new int16_t[size]);
    std::copy(other._raw_heights.get(), other._raw_heights.get() + size, _raw_heights.get());
  }
 
  HeightMap(HeightMap&& other) noexcept = default;
  HeightMap& operator=(const HeightMap& other);
  HeightMap& operator=(HeightMap&& other) = default;
 
  int16_t get(int x, int z) const;
 
  int16_t get_worldspace(const Coordinate2D& loc) const;
 
  void fill_coord(Coordinate& out) const;
 
  uint16_t x_len() const;
 
  uint16_t z_len() const;
 
  Coordinate2D base_pt() const;
 
  struct Iterator {
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = int16_t;
    using pointer = int16_t*;
    using reference = int16_t&;
 
    Iterator(pointer ptr) : m_ptr(ptr) {}
 
    reference operator*() const { return *m_ptr; }
 
    pointer operator->() { return m_ptr; }
 
    Iterator& operator++() {
      m_ptr++;
      return *this;
    }
 
    Iterator operator++(int) {
      Iterator tmp = *this;
      ++(*this);
      return tmp;
    }
 
    friend bool operator==(const Iterator& a, const Iterator& b) { return a.m_ptr == b.m_ptr; };
 
    friend bool operator!=(const Iterator& a, const Iterator& b) { return a.m_ptr != b.m_ptr; };
 
  private:
    pointer m_ptr;
  };
 
  struct ConstIterator {
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = int16_t;
    using pointer = const int16_t*;
    using reference = const int16_t&;
 
    ConstIterator(pointer ptr) : m_ptr(ptr) {}
 
    reference operator*() const { return *m_ptr; }
 
    pointer operator->() { return m_ptr; }
 
    ConstIterator& operator++() {
      m_ptr++;
      return *this;
    }
 
    ConstIterator operator++(int) {
      ConstIterator tmp = *this;
      ++(*this);
      return tmp;
    }
 
    friend bool operator==(const ConstIterator& a, const ConstIterator& b) {
      return a.m_ptr == b.m_ptr;
    };
 
    friend bool operator!=(const ConstIterator& a, const ConstIterator& b) {
      return a.m_ptr != b.m_ptr;
    };
 
  private:
    pointer m_ptr;
  };
 
  Iterator begin() { return Iterator(&_raw_heights[0]); }
  Iterator end() { return Iterator(&_raw_heights[_x_len * _z_len]); }
  ConstIterator begin() const { return ConstIterator(&_raw_heights[0]); }
  ConstIterator end() const { return ConstIterator(&_raw_heights[_x_len * _z_len]); }
};
 
} // namespace mcpp