From 6e67a0f13263b748718c692b4c6481a70b127fda Mon Sep 17 00:00:00 2001 From: Matthias Schiffer Date: Mon, 22 Sep 2014 20:35:45 +0200 Subject: Initial commit --- .gitignore | 1 + CMakeLists.txt | 9 ++++ resources/tile/dirt.png | Bin 0 -> 207 bytes src/CMakeLists.txt | 12 +++++ src/control/MapContext.cpp | 46 ++++++++++++++++ src/control/MapContext.hpp | 57 ++++++++++++++++++++ src/control/TileLoader.cpp | 59 ++++++++++++++++++++ src/control/TileLoader.hpp | 62 +++++++++++++++++++++ src/model/Map.cpp | 53 ++++++++++++++++++ src/model/Map.hpp | 85 +++++++++++++++++++++++++++++ src/rpgedit.cpp | 72 +++++++++++++++++++++++++ src/view/MapView.hpp | 132 +++++++++++++++++++++++++++++++++++++++++++++ src/view/Window.hpp | 66 +++++++++++++++++++++++ 13 files changed, 654 insertions(+) create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100644 resources/tile/dirt.png create mode 100644 src/CMakeLists.txt create mode 100644 src/control/MapContext.cpp create mode 100644 src/control/MapContext.hpp create mode 100644 src/control/TileLoader.cpp create mode 100644 src/control/TileLoader.hpp create mode 100644 src/model/Map.cpp create mode 100644 src/model/Map.hpp create mode 100644 src/rpgedit.cpp create mode 100644 src/view/MapView.hpp create mode 100644 src/view/Window.hpp diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b25c15b --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +*~ diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..b0a5fe3 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,9 @@ +cmake_minimum_required(VERSION 2.8.3) +project(RPGEDIT CXX) + + +find_package(PkgConfig REQUIRED) +pkg_check_modules(SDL2 REQUIRED sdl2 SDL2_image) + + +add_subdirectory(src) diff --git a/resources/tile/dirt.png b/resources/tile/dirt.png new file mode 100644 index 0000000..e6f8b84 Binary files /dev/null and b/resources/tile/dirt.png differ diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000..400481f --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,12 @@ +include_directories(${SDL2_INCLUDE_DIRS}) +link_directories(${SDL2_LIBRARY_DIRS}) + +add_executable(rpgedit + rpgedit.cpp + control/MapContext.cpp + control/TileLoader.cpp + model/Map.cpp +) +set_target_properties(rpgedit PROPERTIES COMPILE_FLAGS "-std=c++11 -Wall ${SDL2_CFLAGS_OTHER}") +set_target_properties(rpgedit PROPERTIES LINK_FLAGS "${SDL2_LDFLAGS_OTHER}") +target_link_libraries(rpgedit ${SDL2_LIBRARIES}) diff --git a/src/control/MapContext.cpp b/src/control/MapContext.cpp new file mode 100644 index 0000000..4d3a4d7 --- /dev/null +++ b/src/control/MapContext.cpp @@ -0,0 +1,46 @@ +/* + Copyright (c) 2014, Matthias Schiffer + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#include "MapContext.hpp" + + +namespace RPGEdit { + +namespace Control { + +MapContext::MapContext(TileLoader *tileLoader0, const std::shared_ptr &map0) + : tileLoader(tileLoader0), map(map0) { + const std::vector &tileset = map->getTileset(); + + tiles.resize(tileset.size()); + + for (size_t i = 0; i < tileset.size(); i++) + tiles[i] = tileLoader->get(tileset[i]); +} + +} + +} diff --git a/src/control/MapContext.hpp b/src/control/MapContext.hpp new file mode 100644 index 0000000..703a582 --- /dev/null +++ b/src/control/MapContext.hpp @@ -0,0 +1,57 @@ +/* + Copyright (c) 2014, Matthias Schiffer + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#pragma once + +#include "TileLoader.hpp" +#include "../model/Map.hpp" +#include "../view/MapView.hpp" + +#include + + +namespace RPGEdit { + +namespace Control { + +class MapContext { +private: + TileLoader *const tileLoader; + + std::shared_ptr map; + std::vector tiles; + +public: + MapContext(TileLoader *tileLoader0, const std::shared_ptr &map0); + + std::shared_ptr initView(const std::shared_ptr &window) { + return std::make_shared(window, map, tiles); + } +}; + +} + +} diff --git a/src/control/TileLoader.cpp b/src/control/TileLoader.cpp new file mode 100644 index 0000000..476ffa4 --- /dev/null +++ b/src/control/TileLoader.cpp @@ -0,0 +1,59 @@ +/* + Copyright (c) 2014, Matthias Schiffer + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#include "TileLoader.hpp" + +#include + + +namespace RPGEdit { + +namespace Control { + +std::unique_ptr TileLoader::loadTile(const std::string &name) { + std::string filename = "../resources/tile/" + name + ".png"; + + SDL_Surface *surface = IMG_Load(filename.c_str()); + + return std::unique_ptr(surface, SDL_Surface_deleter()); +} + +SDL_Surface * TileLoader::get(const std::string &name) { + std::unique_ptr &surface = tiles[name]; + + if (!surface) + surface = loadTile(name); + + if (!surface) + tiles.erase(tiles.find(name)); + + return surface.get(); +} + + +} + +} diff --git a/src/control/TileLoader.hpp b/src/control/TileLoader.hpp new file mode 100644 index 0000000..9fc9dfa --- /dev/null +++ b/src/control/TileLoader.hpp @@ -0,0 +1,62 @@ +/* + Copyright (c) 2014, Matthias Schiffer + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#pragma once + +#include +#include + +#include + + +namespace RPGEdit { + +namespace Control { + +class TileLoader { +private: + class SDL_Surface_deleter { + public: + void operator()(SDL_Surface *surface) { + SDL_FreeSurface(surface); + } + }; + + std::unordered_map> tiles; + + std::unique_ptr loadTile(const std::string &name); + +public: + SDL_Surface * get(const std::string &name); + + void clear() { + tiles.clear(); + } +}; + +} + +} diff --git a/src/model/Map.cpp b/src/model/Map.cpp new file mode 100644 index 0000000..c31f55b --- /dev/null +++ b/src/model/Map.cpp @@ -0,0 +1,53 @@ +/* + Copyright (c) 2014, Matthias Schiffer + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#include "Map.hpp" + + +namespace RPGEdit { + +namespace Model { + +std::shared_ptr Map::load(__attribute__((unused)) const std::string &name) { + std::shared_ptr map(new Map(16, 16)); + + map->tileset.push_back("dirt"); + + for (int i = 0; i < 16; i++) { + for (int j = 0; j < 16; j++) { + if (4 <= i && i < 12 && 4 <= j && j < 12) + map->setTileAt(i, j, 1); + else + map->setTileAt(i, j, 0); + } + } + + return map; +} + +} + +} diff --git a/src/model/Map.hpp b/src/model/Map.hpp new file mode 100644 index 0000000..6d3ef0e --- /dev/null +++ b/src/model/Map.hpp @@ -0,0 +1,85 @@ +/* + Copyright (c) 2014, Matthias Schiffer + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#pragma once + +#include +#include +#include +#include + +namespace RPGEdit { + +namespace Model { + +class Map { +private: + std::vector tileset; + + size_t width, height; + std::unique_ptr tiles; + + Map(size_t width0, size_t height0) + : width(width0), height(height0), tiles(new uint32_t[width*height]) { + } + +public: + std::vector & getTileset() { + return tileset; + } + + const std::vector & getTileset() const { + return tileset; + } + + size_t getWidth() const { + return width; + } + + size_t getHeight() const { + return height; + } + + void setTileAt(size_t x, size_t y, uint32_t value) { + if (x >= width || y >= height) + throw std::range_error("Map::setTileAt: bad coordinates"); + + tiles[y*width + x] = value; + } + + uint32_t getTileAt(ssize_t x, ssize_t y) const { + if (x < 0 || (size_t)x >= width || y < 0 || (size_t)y >= height) + return 0; + + return tiles[y*width + x]; + } + + static std::shared_ptr load(const std::string &name); +}; + +} + +} diff --git a/src/rpgedit.cpp b/src/rpgedit.cpp new file mode 100644 index 0000000..32a28e9 --- /dev/null +++ b/src/rpgedit.cpp @@ -0,0 +1,72 @@ +/* + Copyright (c) 2014, Matthias Schiffer + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#include "control/MapContext.hpp" +#include "view/MapView.hpp" + +#include + +#include +#include + + +extern "C" +int main(__attribute__((unused)) int argc, __attribute__((unused)) char *argv[]) { + using namespace RPGEdit; + + SDL_Init(SDL_INIT_VIDEO); + + { + Control::TileLoader tileLoader; + std::shared_ptr map = Model::Map::load("test"); + + std::shared_ptr ctx(new Control::MapContext(&tileLoader, map)); + + std::shared_ptr window(new View::Window); + std::shared_ptr mapView = ctx->initView(window); + + bool running = true; + + while (true) { + SDL_Event event; + while (SDL_PollEvent(&event)) { + if (event.type == SDL_QUIT) { + running = false; + break; + } + } + + if (!running) + break; + + mapView->render(8, 8); + } + } + + SDL_Quit(); + + return 0; +} diff --git a/src/view/MapView.hpp b/src/view/MapView.hpp new file mode 100644 index 0000000..9150753 --- /dev/null +++ b/src/view/MapView.hpp @@ -0,0 +1,132 @@ +/* + Copyright (c) 2014, Matthias Schiffer + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#pragma once + +#include "Window.hpp" +#include "../model/Map.hpp" + +#include + + +namespace RPGEdit { + +namespace View { + +class MapView { +private: + std::shared_ptr window; + std::shared_ptr map; + SDL_Texture *tileTexture; + +public: + MapView(const std::shared_ptr &window0, + const std::shared_ptr &map0, + const std::vector tiles) + : window(window0), map(map0) { + uint32_t rmask, gmask, bmask, amask; + +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + rmask = 0xff000000; + gmask = 0x00ff0000; + bmask = 0x0000ff00; + amask = 0x000000ff; +#else + rmask = 0x000000ff; + gmask = 0x0000ff00; + bmask = 0x00ff0000; + amask = 0xff000000; +#endif + + SDL_Surface *surface = SDL_CreateRGBSurface(0, 16*tiles.size(), 16, 32, rmask, gmask, bmask, amask); + SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_NONE); + + for (size_t i = 0; i < tiles.size(); i++) { + SDL_Rect rect = { + .x = int(16*i), + .y = 0, + .w = 0, + .h = 0, + }; + + SDL_BlitSurface(tiles[i], nullptr, surface, &rect); + } + + tileTexture = SDL_CreateTextureFromSurface(window->getRenderer(), surface); + SDL_FreeSurface(surface); + } + + ~MapView() { + SDL_DestroyTexture(tileTexture); + } + + void render(float centerX, float centerY) { + SDL_RenderClear(window->getRenderer()); + + std::pair viewport = window->getViewport(); + + float pixels = std::max(viewport.first/16.0f, viewport.second/12.0f); + int tilePixels = 16 * std::ceil(pixels / 16); + + float tilesW = viewport.first / tilePixels; + float tilesH = viewport.second / tilePixels; + + int minX = std::floor(centerX - tilesW/2 - 0.5f), maxX = std::ceil(centerX + tilesW/2 + 0.5f); + int minY = std::floor(centerY - tilesH/2 - 0.5f), maxY = std::ceil(centerY + tilesH/2 + 0.5f); + + int baseX = viewport.first/2 - (centerX + 0.5f)*tilePixels, baseY = viewport.second/2 - (centerY + 0.5f)*tilePixels; + + for (int x = minX; x <= maxX; x++) { + for (int y = minY; y <= maxY; y++) { + uint32_t tile = map->getTileAt(x, y); + if (!tile) + continue; + + SDL_Rect src = { + .x = int(16*(tile-1)), + .y = 0, + .w = 16, + .h = 16, + }; + + SDL_Rect dst = { + .x = baseX + x*tilePixels, + .y = baseY + y*tilePixels, + .w = tilePixels, + .h = tilePixels, + }; + + SDL_RenderCopy(window->getRenderer(), tileTexture, &src, &dst); + } + } + + SDL_RenderPresent(window->getRenderer()); + } +}; + +} + +} diff --git a/src/view/Window.hpp b/src/view/Window.hpp new file mode 100644 index 0000000..c586b57 --- /dev/null +++ b/src/view/Window.hpp @@ -0,0 +1,66 @@ +/* + Copyright (c) 2014, Matthias Schiffer + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#pragma once + +#include + + +namespace RPGEdit { + +namespace View { + +class Window { +private: + SDL_Window *window; + SDL_Renderer *renderer; + +public: + Window() { + window = SDL_CreateWindow("RPGedit", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, SDL_WINDOW_OPENGL|SDL_WINDOW_RESIZABLE); + renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED|SDL_RENDERER_PRESENTVSYNC); + } + + ~Window() { + SDL_DestroyRenderer(renderer); + SDL_DestroyWindow(window); + } + + SDL_Renderer * getRenderer() { + return renderer; + } + + std::pair getViewport() { + int w, h; + SDL_GetWindowSize(window, &w, &h); + + return std::make_pair<>(w, h); + } +}; + +} + +} -- cgit v1.2.3