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

Add pixel_position() to tile iterator.

Browse source
This commit is contained in:
King_DuckZ 2015-08-18 00:03:27 +02:00
parent a1ae683601
commit ae05910316
10 changed files with 49 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
include/doorkeeper/components/basemapsource.hpp
View file

@ -12,6 +12,9 @@
#include <cstddef> #include <cstddef>
namespace dk { namespace dk {
template <uint32_t D>
class PixelConv;
namespace implem { namespace implem {
template <typename T, uint32_t D, bool POD=std::is_pod<T>::value> template <typename T, uint32_t D, bool POD=std::is_pod<T>::value>
class data_fetcher; class data_fetcher;
@ -35,6 +38,7 @@ namespace dk {
virtual int layersCount ( void ) const = 0; virtual int layersCount ( void ) const = 0;
virtual void chainedMaps ( std::vector<std::string>& parOut ) const = 0; virtual void chainedMaps ( std::vector<std::string>& parOut ) const = 0;
virtual HashType layerTypeHash ( int parIndex ) const = 0; virtual HashType layerTypeHash ( int parIndex ) const = 0;
virtual const PixelConv<D>& pixel_conv ( void ) const = 0;
protected: protected:
virtual void fetch_raw ( char* parOut, const coords& parFrom, const coords& parTo, std::size_t parSize ) = 0; virtual void fetch_raw ( char* parOut, const coords& parFrom, const coords& parTo, std::size_t parSize ) = 0;

7
include/doorkeeper/components/pixelconv.hpp
View file

@ -7,10 +7,9 @@
#include <ciso646> #include <ciso646>
namespace dk { namespace dk {
//MapType_IsometricStaggered, template <typename T, uint32_t D, typename T1>
//MapType_Isometric, class TileIterator;
//MapType_Orthogonal,
//MapType_Hex
template <uint32_t D> template <uint32_t D>
class PixelConv { class PixelConv {
public: public:

10
include/doorkeeper/components/tileiterator.hpp
View file

@ -4,6 +4,7 @@
#include "doorkeeper/primitivetypes.hpp" #include "doorkeeper/primitivetypes.hpp"
#include "doorkeeper/implem/helpers.hpp" #include "doorkeeper/implem/helpers.hpp"
#include "doorkeeper/components/tilecoords.hpp" #include "doorkeeper/components/tilecoords.hpp"
#include "doorkeeper/components/pixelconv.hpp"
#include <boost/iterator/iterator_facade.hpp> #include <boost/iterator/iterator_facade.hpp>
#include <iterator> #include <iterator>
#include <vector> #include <vector>
@ -15,6 +16,9 @@ namespace dk {
template <typename T, uint32_t D, typename T1> template <typename T, uint32_t D, typename T1>
class TileIterator; class TileIterator;
template <uint32_t D>
class PixelConv;
namespace implem { namespace implem {
template <typename I, typename O> template <typename I, typename O>
struct TypeWithQualifiers { struct TypeWithQualifiers {
@ -43,12 +47,13 @@ namespace dk {
TileIterator ( void ) = default; TileIterator ( void ) = default;
TileIterator ( const TileIterator& parOther ) = default; TileIterator ( const TileIterator& parOther ) = default;
TileIterator ( TileIterator&& parOther ) = default; TileIterator ( TileIterator&& parOther ) = default;
TileIterator ( qualif_vector_type* parData, const coords& parArea ); TileIterator ( qualif_vector_type* parData, const PixelConv<D>& parPixConv, const coords& parArea );
TileIterator ( qualif_vector_type* parData, const coords& parStart, const coords& parArea ); TileIterator ( qualif_vector_type* parData, const PixelConv<D>& parPixConv, const coords& parStart, const coords& parArea );
~TileIterator ( void ) = default; ~TileIterator ( void ) = default;
const TileCoordsType& raw_coords ( void ) const; const TileCoordsType& raw_coords ( void ) const;
const coords& position ( void ) const; const coords& position ( void ) const;
coords pixel_position ( void ) const;
private: private:
void increment ( void ); void increment ( void );
@ -60,6 +65,7 @@ namespace dk {
TileCoordsType m_tile_range;; TileCoordsType m_tile_range;;
qualif_vector_type* m_data; qualif_vector_type* m_data;
const PixelConv<D>& m_pixel_conv;
}; };
template <uint32_t D> template <uint32_t D>

4
include/doorkeeper/helpers/asciimapsource.hpp
View file

@ -4,6 +4,7 @@
#include "doorkeeper/primitivetypes.hpp" #include "doorkeeper/primitivetypes.hpp"
#include "doorkeeper/implem/vector.hpp" #include "doorkeeper/implem/vector.hpp"
#include "doorkeeper/components/basemapsource.hpp" #include "doorkeeper/components/basemapsource.hpp"
#include "doorkeeper/components/pixelconv.hpp"
#include <vector> #include <vector>
#include <memory> #include <memory>
@ -34,6 +35,7 @@ namespace dkh {
virtual const coords& tileSize ( void ) const; virtual const coords& tileSize ( void ) const;
virtual void chainedMaps ( std::vector<std::string>& parOut ) const; virtual void chainedMaps ( std::vector<std::string>& parOut ) const;
virtual dk::HashType layerTypeHash ( int parIndex ) const; virtual dk::HashType layerTypeHash ( int parIndex ) const;
virtual const dk::PixelConv<2>& pixel_conv ( void ) const;
private: private:
void parse_map_data ( std::istream& parSrc ); void parse_map_data ( std::istream& parSrc );
@ -41,7 +43,7 @@ namespace dkh {
std::vector<MapTileType> m_wholedata; std::vector<MapTileType> m_wholedata;
const coords m_mapSize; const coords m_mapSize;
const coords m_tileSize; const dk::PixelConvSquare<2> m_pixel_conv;
const dk::MapTypes m_mapType; const dk::MapTypes m_mapType;
}; };
} //namespace dkh } //namespace dkh

4
include/doorkeeper/implem/layer.inl
View file

@ -37,14 +37,14 @@ namespace dk {
///-------------------------------------------------------------------------- ///--------------------------------------------------------------------------
template <typename T, uint32_t D> template <typename T, uint32_t D>
typename Layer<T, D>::iterator Layer<T, D>::begin() { typename Layer<T, D>::iterator Layer<T, D>::begin() {
return iterator(&m_tiles, coords(0), this->m_count); return iterator(&m_tiles, m_tilemap->pixel_conv(), coords(0), this->m_count);
} }
///-------------------------------------------------------------------------- ///--------------------------------------------------------------------------
///-------------------------------------------------------------------------- ///--------------------------------------------------------------------------
template <typename T, uint32_t D> template <typename T, uint32_t D>
typename Layer<T, D>::iterator Layer<T, D>::end() { typename Layer<T, D>::iterator Layer<T, D>::end() {
return iterator(&m_tiles, make_past_end_coords<D>(this->m_count - 1), make_past_end_coords<D>(this->m_count - 1)); return iterator(&m_tiles, m_tilemap->pixel_conv(), make_past_end_coords<D>(this->m_count - 1), make_past_end_coords<D>(this->m_count - 1));
} }
///-------------------------------------------------------------------------- ///--------------------------------------------------------------------------

17
include/doorkeeper/implem/tileiterator.inl
View file

@ -1,18 +1,22 @@
namespace dk { namespace dk {
template <typename T, uint32_t D, typename T1> template <typename T, uint32_t D, typename T1>
TileIterator<T, D, T1>::TileIterator (qualif_vector_type* parData, const coords& parArea) : TileIterator<T, D, T1>::TileIterator (qualif_vector_type* parData, const PixelConv<D>& parPixConv, const coords& parArea) :
m_tile_range(parArea), m_tile_range(parArea),
m_data(parData) m_data(parData),
m_pixel_conv(parPixConv)
{ {
DK_ASSERT(parData); DK_ASSERT(parData);
DK_ASSERT(&m_pixel_conv != nullptr);
} }
template <typename T, uint32_t D, typename T1> template <typename T, uint32_t D, typename T1>
TileIterator<T, D, T1>::TileIterator (qualif_vector_type* parData, const coords& parStart, const coords& parArea) : TileIterator<T, D, T1>::TileIterator (qualif_vector_type* parData, const PixelConv<D>& parPixConv, const coords& parStart, const coords& parArea) :
m_tile_range(parStart, parArea), m_tile_range(parStart, parArea),
m_data(parData) m_data(parData),
m_pixel_conv(parPixConv)
{ {
DK_ASSERT(parData); DK_ASSERT(parData);
DK_ASSERT(&m_pixel_conv != nullptr);
} }
template <typename T, uint32_t D, typename T1> template <typename T, uint32_t D, typename T1>
@ -59,6 +63,11 @@ namespace dk {
return m_tile_range.position(); return m_tile_range.position();
} }
template <typename T, uint32_t D, typename T1>
auto TileIterator<T, D, T1>::pixel_position() const -> coords {
return m_pixel_conv.to_pixel(this->position());
}
template <uint32_t D> template <uint32_t D>
inline Vector<D> make_past_end_coords (const Vector<D>& parTo) { inline Vector<D> make_past_end_coords (const Vector<D>& parTo) {
Vector<D> retval(0); Vector<D> retval(0);

8
include/doorkeeper/implem/viewport.inl
View file

@ -20,14 +20,14 @@ namespace dk {
template <typename T> template <typename T>
typename Layer<T, D>::iterator Viewport<D>::begin (Layer<T, D>& parLayer) const { typename Layer<T, D>::iterator Viewport<D>::begin (Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::iterator IterType; typedef typename Layer<T, D>::iterator IterType;
return IterType(&parLayer.m_tiles, m_position, m_tyler.map_size() - 1); return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), m_position, m_tyler.map_size() - 1);
} }
template <uint32_t D> template <uint32_t D>
template <typename T> template <typename T>
typename Layer<T, D>::iterator Viewport<D>::end (Layer<T, D>& parLayer) const { typename Layer<T, D>::iterator Viewport<D>::end (Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::iterator IterType; typedef typename Layer<T, D>::iterator IterType;
return IterType(&parLayer.m_tiles, make_past_end_coords<D>(m_tyler.map_size() - 1), make_past_end_coords<D>(m_tyler.map_size() - 1)); return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), make_past_end_coords<D>(m_tyler.map_size() - 1), make_past_end_coords<D>(m_tyler.map_size() - 1));
} }
template <uint32_t D> template <uint32_t D>
@ -46,14 +46,14 @@ namespace dk {
template <typename T> template <typename T>
typename Layer<T, D>::const_iterator Viewport<D>::cbegin (const Layer<T, D>& parLayer) const { typename Layer<T, D>::const_iterator Viewport<D>::cbegin (const Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::const_iterator IterType; typedef typename Layer<T, D>::const_iterator IterType;
return IterType(&parLayer.m_tiles, m_position, m_tyler.map_size() - 1); return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), m_position, m_tyler.map_size() - 1);
} }
template <uint32_t D> template <uint32_t D>
template <typename T> template <typename T>
typename Layer<T, D>::const_iterator Viewport<D>::cend (const Layer<T, D>& parLayer) const { typename Layer<T, D>::const_iterator Viewport<D>::cend (const Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::const_iterator IterType; typedef typename Layer<T, D>::const_iterator IterType;
return IterType(&parLayer.m_tiles, make_past_end_coords<D>(m_tyler.map_size() - 1), make_past_end_coords<D>(m_tyler.map_size() - 1)); return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), make_past_end_coords<D>(m_tyler.map_size() - 1), make_past_end_coords<D>(m_tyler.map_size() - 1));
} }
template <uint32_t D> template <uint32_t D>

12
src/asciimapsource.cpp
View file

@ -14,7 +14,7 @@ namespace dkh {
///------------------------------------------------------------------------- ///-------------------------------------------------------------------------
AsciiMapSource::AsciiMapSource (const char* parFilename, const coords& parSize, dk::MapTypes parMapType, const coords& parTileSize) : AsciiMapSource::AsciiMapSource (const char* parFilename, const coords& parSize, dk::MapTypes parMapType, const coords& parTileSize) :
m_mapSize(parSize), m_mapSize(parSize),
m_tileSize(parTileSize), m_pixel_conv(parTileSize),
m_mapType(parMapType) m_mapType(parMapType)
{ {
std::ifstream src(parFilename); std::ifstream src(parFilename);
@ -25,7 +25,7 @@ namespace dkh {
///------------------------------------------------------------------------- ///-------------------------------------------------------------------------
AsciiMapSource::AsciiMapSource (const std::string& parFilename, const coords& parSize, dk::MapTypes parMapType, const coords& parTileSize) : AsciiMapSource::AsciiMapSource (const std::string& parFilename, const coords& parSize, dk::MapTypes parMapType, const coords& parTileSize) :
m_mapSize(parSize), m_mapSize(parSize),
m_tileSize(parTileSize), m_pixel_conv(parTileSize),
m_mapType(parMapType) m_mapType(parMapType)
{ {
std::ifstream src(parFilename); std::ifstream src(parFilename);
@ -36,7 +36,7 @@ namespace dkh {
///------------------------------------------------------------------------- ///-------------------------------------------------------------------------
AsciiMapSource::AsciiMapSource (std::istream& parData, const coords& parSize, dk::MapTypes parMapType, const coords& parTileSize) : AsciiMapSource::AsciiMapSource (std::istream& parData, const coords& parSize, dk::MapTypes parMapType, const coords& parTileSize) :
m_mapSize(parSize), m_mapSize(parSize),
m_tileSize(parTileSize), m_pixel_conv(parTileSize),
m_mapType(parMapType) m_mapType(parMapType)
{ {
parse_map_data(parData); parse_map_data(parData);
@ -88,7 +88,7 @@ namespace dkh {
} }
const AsciiMapSource::coords& AsciiMapSource::tileSize() const { const AsciiMapSource::coords& AsciiMapSource::tileSize() const {
return m_tileSize; return m_pixel_conv.tile_size();
} }
void AsciiMapSource::fetch_raw (char* parOut, const coords& parFrom, const coords& parTo, std::size_t parSize) { void AsciiMapSource::fetch_raw (char* parOut, const coords& parFrom, const coords& parTo, std::size_t parSize) {
@ -118,4 +118,8 @@ namespace dkh {
#endif #endif
return dk::type_name_hash<int>(); return dk::type_name_hash<int>();
} }
const dk::PixelConv<2>& AsciiMapSource::pixel_conv() const {
return m_pixel_conv;
}
} //namespace dkh } //namespace dkh

1
test/unit/asciimapsource.cpp
View file

@ -63,6 +63,7 @@ TEST_F(asciimapsource, coordinates) {
const coords2 expected_coords(tsize * itTile.position()); const coords2 expected_coords(tsize * itTile.position());
const auto returned_coords(iso_conv.to_pixel(itTile.position())); const auto returned_coords(iso_conv.to_pixel(itTile.position()));
EXPECT_EQ(expected_coords, returned_coords); EXPECT_EQ(expected_coords, returned_coords);
EXPECT_EQ(expected_coords, itTile.pixel_position());
} }
//Check staggered diamond coordinates, second row reentrant //Check staggered diamond coordinates, second row reentrant

4
test/unit/tileiterator.cpp
View file

@ -1,5 +1,6 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "doorkeeper/components/tileiterator.hpp" #include "doorkeeper/components/tileiterator.hpp"
#include "doorkeeper/components/pixelconv.hpp"
#include <vector> #include <vector>
#include <boost/iterator/counting_iterator.hpp> #include <boost/iterator/counting_iterator.hpp>
#include <limits> #include <limits>
@ -11,10 +12,11 @@ TEST(tileiterator, increment) {
using boost::counting_iterator; using boost::counting_iterator;
std::vector<int> data(counting_iterator<int>(0), counting_iterator<int>(100000)); std::vector<int> data(counting_iterator<int>(0), counting_iterator<int>(100000));
dk::PixelConvSquare<7> pixconv(coords7(16));
{ {
const coords7 max_coords(99, 999, 2, 2, 2, 2, 2); const coords7 max_coords(99, 999, 2, 2, 2, 2, 2);
tileit7 it(&data, max_coords); tileit7 it(&data, pixconv, max_coords);
for (std::size_t z = 0; z < data.size(); ++z) { for (std::size_t z = 0; z < data.size(); ++z) {
EXPECT_EQ(data[z], *it); EXPECT_EQ(data[z], *it);