King_DuckZ
/
DoorKeeper
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

DELEME

This commit is contained in:
King_DuckZ 2015-09-02 17:52:13 +02:00
parent 2841c606c5
commit fd3ea392ac
8 changed files with 95 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/doorkeeper/components/layer.hpp
View File

@ -66,22 +66,26 @@ namespace dk {
typedef typename LayerBase<D>::coords coords;
typedef TileIterator<T, D> iterator;
typedef TileIterator<const T, D> const_iterator;
typedef std::function<void(const Layer<T, D>&, const T&)> EachTileCallback;
Layer ( const Layer& ) = delete;
Layer ( Layer&& ) = default;
explicit Layer ( BaseMapSource<D>* parTilemap );
Layer ( BaseMapSource<D>* parTilemap, EachTileCallback parEachTile );
virtual ~Layer ( void ) noexcept = default;
virtual void each_tile ( const Viewport<D>& parViewport ) const;
Layer& operator= ( const Layer& ) = delete;
iterator begin ( void );
iterator end ( void );
virtual void each_tile ( const Viewport<D>& parViewport ) const;
private:
virtual void onPreload ( const coords& parFrom, const coords& parTo );
std::vector<T> m_tiles;
EachTileCallback m_each_tile;
BaseMapSource<D>* m_tilemap;
};

3
include/doorkeeper/components/layeredviewport.hpp
View File

@ -59,10 +59,11 @@ namespace dk {
const IterableViewport<D> viewport ( const LayerBase<D>& parLayer ) const;
LayeredViewport<D>& operator= ( const LayeredViewport<D>& ) = delete;
LayeredViewport<D>& operator= ( LayeredViewport<D>&& ) = default;
private:
ViewportList m_views;
Tyler<D>& m_tyler;
Tyler<D>* m_tyler;
typename Tyler<D>::LayerObsID m_tyler_id;
};
} //namespace dk

13
include/doorkeeper/components/viewport.hpp
View File

@ -28,16 +28,20 @@ namespace dk {
template <uint32_t D>
class Tyler;
template <typename T, uint32_t D>
class Layer;
template <uint32_t D>
class LayerBase;
template <uint32_t D>
struct TileInfo {
typedef Vector<D> coords;
TileInfo ( const LayerBase<D>& parLayer );
TileInfo ( const TileInfo<D>& ) = default;
TileInfo ( TileInfo<D>&& ) = default;
bool operator== ( const TileInfo& parOther ) const;
TileInfo& operator= ( const TileInfo<D>& ) = default;
TileInfo& operator= ( TileInfo<D>&& ) = default;
coords tile_size;
coords map_size;
@ -55,12 +59,15 @@ namespace dk {
~Viewport ( void ) noexcept = default;
Viewport& operator= ( const Viewport& ) = default;
Viewport& operator= ( Viewport&& ) = default;
Viewport& operator+= ( const coords_f& parValue );
Viewport& operator-= ( const coords_f& parValue );
void setFrom ( const coords& parFrom );
coords size ( void ) const;
coords pixel_offset ( void ) const;
const coords& upper ( void ) const;
const coords& block_position ( void ) const;
private:
void clip_pixel_offset ( void );
@ -68,7 +75,7 @@ namespace dk {
TileCoords<D> m_view;
coords_f m_pixel_offset;
Tyler<D>* m_tyler;
const TileInfo<D>* const m_tile_info;
const TileInfo<D>* m_tile_info;
};
} //namespace dk

22
include/doorkeeper/implem/layer.inl
View File

@ -61,7 +61,16 @@ namespace dk {
///--------------------------------------------------------------------------
template <typename T, uint32_t D>
Layer<T, D>::Layer (BaseMapSource<D>* parTilemap) :
Layer<T, D>(parTilemap, EachTileCallback(nullptr))
{
}
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <typename T, uint32_t D>
Layer<T, D>::Layer (BaseMapSource<D>* parTilemap, EachTileCallback parEachTile) :
LayerBase<D>(parTilemap->mapSize(), parTilemap->tileSize()),
m_each_tile(parEachTile),
m_tilemap(parTilemap)
{
DK_ASSERT(m_tilemap);
@ -95,7 +104,16 @@ namespace dk {
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <typename T, uint32_t D>
void Layer<T, D>::each_tile(const Viewport<D>& parViewport) const {
DK_ASSERT(false); //TODO not implemented
void Layer<T, D>::each_tile (const Viewport<D>& parViewport) const {
if (not m_each_tile) {
return;
}
const_iterator it(&m_tiles, m_tilemap->pixel_conv(), parViewport.block_position(), make_past_end_coords(parViewport.upper()));
const_iterator it_end(&m_tiles, m_tilemap->pixel_conv(), make_past_end_coords(parViewport.upper()), make_past_end_coords(parViewport.upper()));
for (; it != it_end; ++it) {
m_each_tile(*this, *it);
}
}
}

37
include/doorkeeper/implem/layeredviewport.inl
View File

@ -28,7 +28,7 @@ namespace dk {
bool operator== ( const TileInfo<D>& parOther ) const a_pure;
ViewportItem& operator= ( const ViewportItem& ) = default;
ViewportItem& operator= ( ViewportItem&& ) = delete;
ViewportItem& operator= ( ViewportItem&& );
};
template <uint32_t D>
@ -44,6 +44,14 @@ namespace dk {
return tile_info == parOther;
}
template <uint32_t D>
typename LayeredViewport<D>::ViewportItem& LayeredViewport<D>::ViewportItem::operator= (ViewportItem&& parOther) {
tile_info = std::move(parOther.tile_info);
viewport = std::move(parOther.viewport);
ref_count = parOther.ref_count;
return *this;
}
template <uint32_t D>
LayeredViewport<D>::LayeredViewport (LayeredViewport<D>&& parOther) :
m_views(std::move(parOther.m_views)),
@ -54,20 +62,21 @@ namespace dk {
template <uint32_t D>
LayeredViewport<D>::LayeredViewport (Tyler<D>& parTyler) :
m_tyler(parTyler)
m_tyler(&parTyler)
{
for (const auto& layer : m_tyler) {
DK_ASSERT(m_tyler);
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));
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);
m_tyler->unregister_for_layeradd(m_tyler_id);
}
template <uint32_t D>
@ -93,7 +102,7 @@ namespace dk {
if (parAdded) {
if (m_views.end() == it_found) {
m_views.emplace_back(ViewportItem(tinfo, m_tyler));
m_views.emplace_back(ViewportItem(tinfo, *m_tyler));
}
else {
++it_found->ref_count;
@ -112,37 +121,39 @@ namespace dk {
auto LayeredViewport<D>::begin() -> iterator {
IterableViewport<D> (LayeredViewport<D>::*vpfunc)(const LayerBase<D>&) = &LayeredViewport<D>::viewport;
boost::function<IterableViewport<D>(const LayerBase<D>&)> functor = boost::bind(vpfunc, this, _1);
auto it_beg = m_tyler.begin();
auto it_beg = m_tyler->begin();
return boost::make_transform_iterator(it_beg, functor);
}
template <uint32_t D>
auto LayeredViewport<D>::begin() const -> const_iterator {
const IterableViewport<D> (LayeredViewport<D>::*vpfunc)(const LayerBase<D>&) const = &LayeredViewport<D>::viewport;
return const_iterator(m_tyler.begin(), boost::bind(&vpfunc, this, _1));
return const_iterator(m_tyler->begin(), boost::bind(&vpfunc, this, _1));
}
template <uint32_t D>
auto LayeredViewport<D>::end() -> iterator {
IterableViewport<D> (LayeredViewport<D>::*vpfunc)(const LayerBase<D>&) = &LayeredViewport<D>::viewport;
boost::function<IterableViewport<D>(const LayerBase<D>&)> functor = boost::bind(vpfunc, this, _1);
return boost::make_transform_iterator(m_tyler.end(), functor);
return boost::make_transform_iterator(m_tyler->end(), functor);
}
template <uint32_t D>
auto LayeredViewport<D>::end() const -> const_iterator {
const IterableViewport<D> (LayeredViewport<D>::*vpfunc)(const LayerBase<D>&) const = &LayeredViewport<D>::viewport;
return const_iterator(m_tyler.end(), boost::bind(&vpfunc, this, _1));
return const_iterator(m_tyler->end(), boost::bind(&vpfunc, this, _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));
return 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);
const TileInfo<D> tinfo(parLayer);
auto it_found = std::find(m_views.begin(), m_views.end(), tinfo);
DK_ASSERT(m_views.end() != it_found);
return IterableViewport<D>(&it_found->viewport, &parLayer);
}
} //namespace dk

50
include/doorkeeper/implem/viewport.inl
View File

@ -53,46 +53,6 @@ namespace dk {
m_tyler->preload(m_view.position(), m_view.position() + this->size());
}
template <uint32_t D>
template <typename T>
typename Layer<T, D>::iterator Viewport<D>::begin (Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::iterator IterType;
return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), m_view.position(), m_view.upper());
}
template <uint32_t D>
template <typename T>
typename Layer<T, D>::iterator Viewport<D>::end (Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::iterator IterType;
return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), make_past_end_coords<D>(m_view.upper()), make_past_end_coords<D>(m_view.upper()));
}
template <uint32_t D>
template <typename T>
typename Layer<T, D>::const_iterator Viewport<D>::begin (const Layer<T, D>& parLayer) const {
return this->cbegin(parLayer);
}
template <uint32_t D>
template <typename T>
typename Layer<T, D>::const_iterator Viewport<D>::end (const Layer<T, D>& parLayer) const {
return this->cend(parLayer);
}
template <uint32_t D>
template <typename T>
typename Layer<T, D>::const_iterator Viewport<D>::cbegin (const Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::const_iterator IterType;
return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), m_view.position(), m_view.upper());
}
template <uint32_t D>
template <typename T>
typename Layer<T, D>::const_iterator Viewport<D>::cend (const Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::const_iterator IterType;
return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), make_past_end_coords<D>(m_view.upper()), make_past_end_coords<D>(m_view.upper()));
}
template <uint32_t D>
void Viewport<D>::setFrom (const coords& parFrom) {
DK_ASSERT(this->size() + parFrom <= m_tile_info->map_size);
@ -149,4 +109,14 @@ namespace dk {
auto Viewport<D>::pixel_offset() const -> coords {
return static_cast<coords>(m_pixel_offset);
}
template <uint32_t D>
auto Viewport<D>::upper() const -> const coords& {
return m_view.upper();
}
template <uint32_t D>
auto Viewport<D>::block_position() const -> const coords& {
return m_view.position();
}
} //namespace dk

22
lib/vectorwrapper/include/vectorwrapper/vectorwrapper.hpp
View File

@ -52,6 +52,8 @@ namespace vwr {
Vec<V1>& assign ( Vec<V1, D>& parLeft, const Vec<V2, D>& parRight );
template <typename V>
Vec<V>& assign_same_type ( Vec<V>& parLeft, const Vec<V>& parRight );
template <typename V>
Vec<V>& move_same_type ( Vec<V>& parLeft, Vec<V>&& parRight );
template <typename T, dim_type I> struct get_offset_enum_from_index;
template <typename T> struct get_offset_enum_from_index<T, 0> {
@ -141,6 +143,7 @@ namespace vwr {
template <typename V>
class VecBase {
friend Vec<V>& assign_same_type<V> ( Vec<V>& parLeft, const Vec<V>& parRight );
friend Vec<V>& move_same_type<V> ( Vec<V>& parLeft, Vec<V>&& parRight );
public:
typedef V vector_type;
typedef typename VectorWrapperInfo<V>::scalar_type scalar_type;
@ -150,6 +153,8 @@ namespace vwr {
};
VecBase ( void ) = default;
VecBase ( const VecBase& ) = default;
VecBase ( VecBase&& ) = default;
template <typename T>
explicit VecBase ( const T& parInit, typename std::enable_if<std::is_same<T, scalar_type>::value and not std::is_same<scalar_type, vector_type>::value, bool>::type=false );
explicit VecBase ( const vector_type& parInit );
@ -314,10 +319,13 @@ namespace vwr {
dimensions = S
};
template <typename... Args>
Vec ( Args... parArgs ) : implem::VecBase<V>(std::forward<Args>(parArgs)...)
{
}
Vec ( void ) = default;
Vec ( const Vec& ) = default;
Vec ( Vec&& ) = default;
using implem::VecBase<V>::VecBase;
Vec& operator= ( const Vec& parOther ) { return implem::assign_same_type(*this, parOther); }
Vec& operator= ( Vec&& parOther ) { return implem::move_same_type(*this, std::move(parOther)); }
};
template <typename V>
@ -334,12 +342,14 @@ namespace vwr {
Vec ( void ) = default;
Vec ( const Vec& ) = default;
Vec ( Vec&& ) = default;
explicit Vec ( const vector_type& parIn ) : implem::VecBase<V>(parIn) { }
template <typename T>
explicit Vec ( const typename std::enable_if<std::is_same<T, scalar_type>::value and not std::is_same<scalar_type, vector_type>::value, T>::type& parX ) : implem::VecBase<V>(parX) { }
template <typename V2> Vec ( const Vec<V2, dimensions>& parOther ) { implem::assign(*this, parOther); }
Vec& operator= ( const Vec& parOther ) { return implem::assign_same_type(*this, parOther); }
Vec& operator= ( Vec&& parOther ) { return implem::move_same_type(*this, std::move(parOther)); }
template <typename V2>
Vec& operator= ( const Vec<V2, dimensions>& parOther ) { return implem::assign(*this, parOther); }
};
@ -360,12 +370,14 @@ namespace vwr {
Vec ( void ) = default;
Vec ( const Vec& ) = default;
Vec ( Vec&& ) = default;
explicit Vec ( const vector_type& parIn ) : implem::VecBase<V>(parIn) { }
explicit Vec ( const scalar_type parX ) : implem::VecBase<V>(parX) { }
Vec ( scalar_type parX, scalar_type parY ) : implem::VecBase<V>(parX, parY) { }
template <typename V2> Vec ( const Vec<V2, dimensions>& parOther ) { implem::assign(*this, parOther); }
Vec& operator= ( const Vec& parOther ) { return implem::assign_same_type(*this, parOther); }
Vec& operator= ( Vec&& parOther ) { return implem::move_same_type(*this, std::move(parOther)); }
template <typename V2>
Vec& operator= ( const Vec<V2, dimensions>& parOther ) { return implem::assign(*this, parOther); }
Vec& operator= ( const vector_type& parOther ) { this->data() = parOther; return *this; }
@ -388,12 +400,14 @@ namespace vwr {
Vec ( void ) = default;
Vec ( const Vec& ) = default;
Vec ( Vec&& ) = default;
explicit Vec ( const vector_type& parIn ) : implem::VecBase<V>(parIn) { }
explicit Vec ( const scalar_type parX ) : implem::VecBase<V>(parX) { }
Vec ( scalar_type parX, scalar_type parY, scalar_type parZ ) : implem::VecBase<V>(parX, parY, parZ) { }
template <typename V2> Vec ( const Vec<V2, dimensions>& parOther ) { implem::assign(*this, parOther); }
Vec& operator= ( const Vec& parOther ) { return implem::assign_same_type(*this, parOther); }
Vec& operator= ( Vec&& parOther ) { return implem::move_same_type(*this, std::move(parOther)); }
template <typename V2>
Vec& operator= ( const Vec<V2, dimensions>& parOther ) { return implem::assign(*this, parOther); }
Vec& operator= ( const vector_type& parOther ) { this->data() = parOther; return *this; }

6
lib/vectorwrapper/include/vectorwrapper/vectorwrapper.inl
View File

@ -188,6 +188,12 @@ namespace vwr {
return parLeft;
}
template <typename V>
Vec<V>& move_same_type (Vec<V>& parLeft, Vec<V>&& parRight) {
parLeft.m_wrapped = std::move(parRight.m_wrapped);
return parLeft;
}
template <typename V>
auto Vec3Demotion<V, true>::xy() const -> lower_vector_type {
auto& this_vec = *static_cast<const Vec<V>*>(this);