bitmap_type.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef BITMAP_TYPE_HPP
#define BITMAP_TYPE_HPP
 

class BitmapTileArea : public TileArea {
protected:
  std::vector<bool> data;
 
  inline uint Index(uint x, uint y) const { return y * this->w + x; }
 
  inline uint Index(TileIndex tile) const { return Index(TileX(tile) - TileX(this->tile), TileY(tile) - TileY(this->tile)); }
 
public:
  BitmapTileArea()
  {
    this->tile = INVALID_TILE;
    this->w = 0;
    this->h = 0;
  }
 
  BitmapTileArea(const TileArea &ta)
  {
    this->tile = ta.tile;
    this->w = ta.w;
    this->h = ta.h;
    this->data.resize(Index(this->w, this->h));
  }

  void Reset()
  {
    this->tile = INVALID_TILE;
    this->w = 0;
    this->h = 0;
    this->data.clear();
  }

  void Initialize(const Rect &r)
  {
    this->tile = TileXY(r.left, r.top);
    this->w = r.Width();
    this->h = r.Height();
    this->data.clear();
    this->data.resize(Index(w, h));
  }
 
  void Initialize(const TileArea &ta)
  {
    this->tile = ta.tile;
    this->w = ta.w;
    this->h = ta.h;
    this->data.clear();
    this->data.resize(Index(w, h));
  }

  inline void SetTile(TileIndex tile)
  {
    assert(this->Contains(tile));
    this->data[Index(tile)] = true;
  }

  inline void ClrTile(TileIndex tile)
  {
    assert(this->Contains(tile));
    this->data[Index(tile)] = false;
  }

  inline bool HasTile(TileIndex tile) const
  {
    return this->Contains(tile) && this->data[Index(tile)];
  }
};

class BitmapTileIterator : public OrthogonalTileIterator {
protected:
  const BitmapTileArea *bitmap;
public:
  BitmapTileIterator(const BitmapTileArea &bitmap) : OrthogonalTileIterator(bitmap), bitmap(&bitmap)
  {
    if (!this->bitmap->HasTile(TileIndex(this->tile))) ++(*this);
  }
 
  inline TileIterator& operator ++() override
  {
    this->OrthogonalTileIterator::operator++();
    while (this->tile != INVALID_TILE && !this->bitmap->HasTile(TileIndex(this->tile))) {
      this->OrthogonalTileIterator::operator++();
    }
    return *this;
  }
 
  std::unique_ptr<TileIterator> Clone() const override
  {
    return std::make_unique<BitmapTileIterator>(*this);
  }
};
 
#endif /* BITMAP_TYPE_HPP */