277 lines
8.9 KiB
C++
277 lines
8.9 KiB
C++
#include "doorkeeper/doorkeeper.hpp"
|
|
#include "doorkeepertestConfig.h"
|
|
#include "platform.h"
|
|
#include "platformstrings.h"
|
|
#include "doorkeeper/helpers/asciimapsource.hpp"
|
|
#include "doorkeeper/helpers/tilecoordinates.hpp"
|
|
#include "doorkeeper/helpers/maploader.hpp"
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <string>
|
|
#include <memory>
|
|
#include <ciso646>
|
|
#include <utility>
|
|
#include <cstring>
|
|
|
|
#include <SDL2/SDL.h>
|
|
#include <SDL2/SDL_image.h>
|
|
|
|
template <typename Device, typename Tile>
|
|
struct LayerWithData {
|
|
std::unique_ptr<dkh::AsciiMapSource> device;
|
|
dk::Layer<Tile, 2>* layer;
|
|
std::string path;
|
|
};
|
|
|
|
#include "doorkeeper/helpers/typename.hpp"
|
|
|
|
std::ostream& operator<< (std::ostream& parStream, const dk::HashType& parHash) {
|
|
parStream << std::hex << parHash.a << parHash.b << parHash.c;
|
|
return parStream;
|
|
}
|
|
|
|
namespace {
|
|
typedef std::unique_ptr<SDL_Renderer, void(*)(SDL_Renderer*)> SDLRendererUPtr;
|
|
typedef std::unique_ptr<SDL_Window, void(*)(SDL_Window*)> SDLWindowUPtr;
|
|
typedef std::unique_ptr<SDL_Texture, void(*)(SDL_Texture*)> SDLTextureUPtr;
|
|
|
|
struct SDLSimple {
|
|
SDLSimple ( void );
|
|
~SDLSimple ( void ) noexcept;
|
|
bool initialized;
|
|
};
|
|
|
|
void printWelcome ( void );
|
|
void addLayer ( dk::Tyler<2>& parTiler, LayerWithData<dkh::AsciiMapSource, int>& parLayerInfo, const char* parPath );
|
|
void printViewport ( const dk::Viewport<2>& parView, const dk::Layer<int, 2>& parLayer );
|
|
std::pair<int, std::string> GetRenderingDriver ( void );
|
|
void draw_tiles ( SDL_Renderer* parRenderer, SDL_Texture* parTile0, SDL_Texture* parTile1, const dk::Viewport<2>& parView, const dk::Layer<int, 2>& parLayer, int parYOffs );
|
|
} //unnamed namespace
|
|
|
|
int main() {
|
|
typedef dk::Tyler<2>::coords coords2;
|
|
std::cout << dk::type_name<coords2>() << '\n';
|
|
std::cout << dk::type_name<dk::Tyler<2>::coords>() << '\n';
|
|
std::cout << dk::type_name<int>() << '\n';
|
|
std::cout << dk::type_name<float>() << '\n';
|
|
std::cout << dk::type_name<std::vector<std::pair<std::map<std::string, unsigned short int>, bool>>>() << '\n';
|
|
std::cout << dk::type_name_hash<dk::Tyler<2>>() << '\n';
|
|
|
|
static constexpr auto h = dk::tiger("message digest", 14, 0x01);
|
|
std::cout << std::hex << h.a << '\n' << 0x951A2078CBF881D9ULL << std::endl;
|
|
|
|
static constexpr auto h2 = dk::tiger("abc", 3, 0x01);
|
|
std::cout << std::hex << h2.a << '\n' << 0xF258C1E88414AB2AULL << std::endl;
|
|
|
|
static constexpr auto h3 = dk::tiger("", 0, 0x01);
|
|
std::cout << std::hex << h3.a << '\n' << 0x24F0130C63AC9332ULL << std::endl;
|
|
|
|
{
|
|
static constexpr dk::HashType hashtest(1, 2, 3);
|
|
static_assert(hashtest.a == 1, "wrong value");
|
|
static_assert(hashtest.b == 2, "wrong value");
|
|
static_assert(hashtest.c == 3, "wrong value");
|
|
}
|
|
{
|
|
static constexpr dk::HashType hashtest(2, 'c', 0, 'a', 1, 'b');
|
|
static_assert(hashtest.a == 'a', "wrong value");
|
|
static_assert(hashtest.b == 'b', "wrong value");
|
|
static_assert(hashtest.c == 'c', "wrong value");
|
|
}
|
|
{
|
|
const uint64_t test = *reinterpret_cast<const uint64_t*>("A\0\0\0\0\0\0");
|
|
if ((test & 0xFF) != 'A')
|
|
throw 1;
|
|
}
|
|
return 0;
|
|
|
|
typedef dk::Tyler<2>::coords coords2;
|
|
using dkh::AsciiMapSource;
|
|
|
|
SDLSimple sdl_init;
|
|
if (not sdl_init.initialized)
|
|
return 1;
|
|
|
|
printWelcome();
|
|
|
|
SDLWindowUPtr sdl_window(
|
|
SDL_CreateWindow("DoorKeeper test", 100, 100, 128 * 6, 128 * 4, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE),
|
|
&SDL_DestroyWindow
|
|
);
|
|
const auto rendererDriver = GetRenderingDriver();
|
|
SDLRendererUPtr sdl_renderer(
|
|
SDL_CreateRenderer(sdl_window.get(), rendererDriver.first, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC),
|
|
&SDL_DestroyRenderer
|
|
);
|
|
|
|
dk::Tyler<2> tiler(coords2(64));
|
|
|
|
LayerWithData<AsciiMapSource, int> bottomLayer;
|
|
addLayer(tiler, bottomLayer, DATA_PATH"/test.map");
|
|
|
|
LayerWithData<AsciiMapSource, int> topLayer;
|
|
addLayer(tiler, topLayer, DATA_PATH"/test_2.map");
|
|
|
|
printViewport(dk::Viewport<2>(tiler, coords2(10, 6), coords2(0)), *bottomLayer.layer);
|
|
printViewport(dk::Viewport<2>(tiler, coords2(4, 4), coords2(0)), *bottomLayer.layer);
|
|
|
|
#if !defined(NDEBUG)
|
|
std::cout << "Map size: " << tiler.map_size() << '\n';
|
|
#endif
|
|
std::cout << "Total tiles: " << tiler.tiles_count() << '\n';
|
|
|
|
//Load resources
|
|
SDLTextureUPtr tile_0(nullptr, &SDL_DestroyTexture), tile_1(nullptr, &SDL_DestroyTexture);
|
|
{
|
|
tile_0 = SDLTextureUPtr(IMG_LoadTexture(sdl_renderer.get(), "tile_0.png"), &SDL_DestroyTexture);
|
|
tile_1 = SDLTextureUPtr(IMG_LoadTexture(sdl_renderer.get(), "tile_1.png"), &SDL_DestroyTexture);
|
|
}
|
|
|
|
//Main loop
|
|
bool running = true;
|
|
int y = 0;
|
|
dk::Viewport<2> viewport(tiler, coords2(10, 8), coords2(0));
|
|
coords2 tile_size;
|
|
SDL_QueryTexture(tile_0.get(), nullptr, nullptr, &tile_size.x(), &tile_size.y());
|
|
do {
|
|
SDL_RenderClear(sdl_renderer.get());
|
|
viewport.setFrom(coords2(0, y / tile_size.y()));
|
|
draw_tiles(sdl_renderer.get(), tile_0.get(), tile_1.get(), viewport, *bottomLayer.layer, -(y % tile_size.y()));
|
|
//++y;
|
|
if (tile_size.y() * bottomLayer.layer->mapSize().y() == y)
|
|
y = 0;
|
|
SDL_RenderPresent(sdl_renderer.get());
|
|
|
|
SDL_Delay(1000 / 60);
|
|
SDL_Event eve;
|
|
while (SDL_PollEvent(&eve)) {
|
|
switch (eve.type) {
|
|
case SDL_KEYDOWN:
|
|
////eve.key.keysym.sym
|
|
//parInput.NotifyKeyAction(InputDevice_Keyboard, eve.key.keysym.scancode, true);
|
|
break;
|
|
|
|
case SDL_KEYUP:
|
|
//parInput.NotifyKeyAction(InputDevice_Keyboard, eve.key.keysym.scancode, false);
|
|
break;
|
|
|
|
case SDL_QUIT:
|
|
running = false;
|
|
|
|
case SDL_WINDOWEVENT:
|
|
if (SDL_WINDOWEVENT_RESIZED == eve.window.event) {
|
|
//parSdlMain->SetResolution(ushort2(static_cast<uint16_t>(eve.window.data1), static_cast<uint16_t>(eve.window.data2)));
|
|
}
|
|
else if (SDL_WINDOWEVENT_CLOSE == eve.window.event) {
|
|
running = false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} while(running);
|
|
return 0;
|
|
}
|
|
|
|
namespace {
|
|
void printWelcome() {
|
|
std::cout << "Welcome to " << APP_NAME << ' ' << DK_DEVICE_STRING << " version for " << DK_OS_STRING << ' ' << DK_ARCH_STRING << ' ' << DK_BIT_STRING;
|
|
#if defined(DK_ARM)
|
|
std::cout << ' ' << DK_ARM_FAMILY_STRING << ' ' << DK_ARM_ARCH_STRING;
|
|
#endif
|
|
std::cout << '\n';
|
|
}
|
|
|
|
void addLayer (dk::Tyler<2>& parTiler, LayerWithData<dkh::AsciiMapSource, int>& parLayerInfo, const char* parPath) {
|
|
typedef dkh::AsciiMapSource::coords coords;
|
|
|
|
parLayerInfo.path = parPath;
|
|
parLayerInfo.device.reset(new dkh::AsciiMapSource(parLayerInfo.path, coords(10, 8), dk::MapType_IsometricStaggered, coords(64, 64)));
|
|
parLayerInfo.layer = &parTiler.push_layer<int>(parLayerInfo.device.get(), 0);
|
|
}
|
|
|
|
void printViewport (const dk::Viewport<2>& parView, const dk::Layer<int, 2>& parLayer) {
|
|
int col = 0;
|
|
const auto tilecount = parView.count();
|
|
for (auto itTile = parView.begin(parLayer), itTileEND = parView.end(parLayer); itTile != itTileEND; ++itTile) {
|
|
std::cout << *itTile;
|
|
++col;
|
|
if (col == tilecount.x()) {
|
|
col = 0;
|
|
std::cout << '\n';
|
|
}
|
|
}
|
|
}
|
|
|
|
SDLSimple::SDLSimple() {
|
|
if (SDL_Init(SDL_INIT_EVERYTHING) == -1) {
|
|
std::cerr << "Error initializing SDL" << std::endl;
|
|
initialized = false;
|
|
}
|
|
else {
|
|
initialized = true;
|
|
}
|
|
}
|
|
|
|
SDLSimple::~SDLSimple() noexcept {
|
|
if (initialized) {
|
|
initialized = false;
|
|
SDL_Quit();
|
|
}
|
|
}
|
|
|
|
std::pair<int, std::string> GetRenderingDriver() {
|
|
typedef std::pair<int, std::string> RetPairType;
|
|
|
|
const int count = SDL_GetNumRenderDrivers();
|
|
int opengles = -1;
|
|
int opengles2 = -1;
|
|
int opengl = -1;
|
|
SDL_RendererInfo info;
|
|
for (int z = 0; z < count; ++z) {
|
|
const int ret = SDL_GetRenderDriverInfo(z, &info);
|
|
if (0 == ret) {
|
|
if (std::strcmp("opengles", info.name) == 0)
|
|
opengles = z;
|
|
else if (std::strcmp("opengles2", info.name) == 0)
|
|
opengles2 = z;
|
|
else if (std::strcmp("opengl", info.name) == 0)
|
|
opengl = z;
|
|
}
|
|
}
|
|
if (opengl > -1)
|
|
return RetPairType(opengl, "opengl");
|
|
if (opengles2 > -1)
|
|
return RetPairType(opengles2, "opengles2");
|
|
if (opengles > -1)
|
|
return RetPairType(opengles, "opengles");
|
|
|
|
return RetPairType(-1, "default");
|
|
}
|
|
|
|
void draw_tiles (SDL_Renderer* parRenderer, SDL_Texture* parTile0, SDL_Texture* parTile1, const dk::Viewport<2>& parView, const dk::Layer<int, 2>& parLayer, int parYOffs) {
|
|
typedef dk::Tyler<2>::coords coords2;
|
|
SDL_Rect rect_src;
|
|
rect_src.x = rect_src.y = 0;
|
|
coords2 original_size;
|
|
SDL_QueryTexture(parTile0, nullptr, nullptr, &original_size.x(), &original_size.y());
|
|
rect_src.w = original_size.x();
|
|
rect_src.h = original_size.y();
|
|
const coords2 tilesize(original_size.x(), original_size.y() - 47);
|
|
const int offsets[2] = {5, 0};
|
|
|
|
for (auto itTile = parView.begin(parLayer), itTileEND = parView.end(parLayer); itTile != itTileEND; ++itTile) {
|
|
SDL_Rect rect_dst;
|
|
const auto pixel_pos = dkh::get_diamond_coordinates(itTile, tilesize);
|
|
rect_src.y = offsets[*itTile];
|
|
rect_src.h = original_size.y() - offsets[*itTile];
|
|
|
|
rect_dst.x = pixel_pos.x();
|
|
rect_dst.y = pixel_pos.y() + parYOffs;
|
|
rect_dst.w = rect_src.w;
|
|
rect_dst.h = rect_src.h;
|
|
SDL_Texture* const curr_texture = (1 == *itTile ? parTile1 : parTile0);
|
|
SDL_RenderCopy(parRenderer, curr_texture, &rect_src, &rect_dst);
|
|
}
|
|
}
|
|
} //unnamed namespace
|