DoorKeeper/include/doorkeeper/implem/layeredviewport.inl

/* Copyright 2015, Michele Santullo
 * This file is part of DoorKeeper.
 *
 * DoorKeeper 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, either version 3 of the License, or
 * (at your option) any later version.
 *
 * DoorKeeper 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 DoorKeeper.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace dk {
	template <uint32_t D>
	struct LayeredViewport<D>::ViewportItem {
		ViewportItem ( const TileInfo<D>& parTInfo, Tyler<D>& parTyler );
		ViewportItem ( ViewportItem&& ) = default;

		TileInfo<D> tile_info;
		Viewport<D> viewport;
		int ref_count;

		bool operator== ( const TileInfo<D>& parOther ) const a_pure;
	};

	template <uint32_t D>
	LayeredViewport<D>::ViewportItem::ViewportItem (const TileInfo<D>& parTInfo, Tyler<D>& parTyler) :
		tile_info(parTInfo),
		viewport(parTyler, &tile_info),
		ref_count(1)
	{
	}

	template <uint32_t D>
	bool LayeredViewport<D>::ViewportItem::operator== (const TileInfo<D>& parOther) const {
		return tile_info == parOther;
	}

	template <uint32_t D>
	LayeredViewport<D>::LayeredViewport (Tyler<D>& parTyler) :
		m_tyler(parTyler)
	{
		for (const auto& layer : m_tyler) {
			this->on_layer(layer, true);
		}

		using std::placeholders::_1;
		using std::placeholders::_2;
		m_tyler_id = m_tyler.register_for_layeradd(std::bind(&LayeredViewport<D>::on_layer, this, _1, _2));
	}

	template <uint32_t D>
	LayeredViewport<D>::~LayeredViewport() noexcept {
		m_tyler.unregister_for_layeradd(m_tyler_id);
	}

	template <uint32_t D>
	LayeredViewport<D>& LayeredViewport<D>::operator+= (const coords_f& parValue) {
		for (auto& view : m_views) {
			view.viewport += parValue;
		}
		return *this;
	}

	template <uint32_t D>
	LayeredViewport<D>& LayeredViewport<D>::operator-= (const coords_f& parValue) {
		for (auto& view : m_views) {
			view.viewport -= parValue;
		}
		return *this;
	}

	template <uint32_t D>
	void LayeredViewport<D>::on_layer (const LayerBase<D>& parLayer, bool parAdded) {
		const TileInfo<D> tinfo(parLayer);
		auto it_found = std::find(m_views.begin(), m_views.end(), tinfo);

		if (parAdded) {
			if (m_views.end() == it_found) {
				m_views.push_back(ViewportItem(tinfo, m_tyler));
			}
			else {
				++it_found->ref_count;
			}
		}
		else {
			DK_ASSERT(m_views.end() != it_found);
			--it_found->ref_count;
			if (0 == it_found->ref_count) {
				m_views.erase(it_found);
			}
		}
	}

	template <uint32_t D>
	auto LayeredViewport<D>::begin() -> iterator {
		return iterator(m_views.begin(), std::bind(&LayeredViewport<D>::viewport, this, std::placeholders::_1));
	}

	template <uint32_t D>
	auto LayeredViewport<D>::begin() const -> const_iterator {
		return const_iterator(m_views.begin(), std::bind(&LayeredViewport<D>::viewport, this, std::placeholders::_1));
	}

	template <uint32_t D>
	auto LayeredViewport<D>::end() -> iterator {
		return iterator(m_views.end(), std::bind(&LayeredViewport<D>::viewport, this, std::placeholders::_1));
	}

	template <uint32_t D>
	auto LayeredViewport<D>::end() const -> const_iterator {
		return const_iterator(m_views.end(), std::bind(&LayeredViewport<D>::viewport, this, std::placeholders::_1));
	}

	template <uint32_t D>
	IterableViewport<D> LayeredViewport<D>::viewport (const LayerBase<D>& parLayer) {
		return const_cast<Viewport<D>&>(const_cast<const LayeredViewport<D>*>(this)->viewport(parLayer));
	}

	template <uint32_t D>
	const IterableViewport<D> LayeredViewport<D>::viewport (const LayerBase<D>& parLayer) const {
		const TileInfo<D> tinfo { parLayer.tile_size(), parLayer.map_size() };
		return IterableViewport<D>(&m_views[tinfo].first, &parLayer);
	}
} //namespace dk