gosu 1.4.6 → 2.0.0.pre6

data/src/IO.cpp

@@ -1,60 +0,0 @@
-#include <Gosu/IO.hpp>
-#include <cassert>
-#include <cstring>
-using namespace std;
-
-void Gosu::Reader::read(void* dest, size_t length)
-{
-    res->read(pos, length, dest);
-    seek(length);
-}
-
-void Gosu::Writer::write(const void* source, size_t length)
-{
-    // Try to resize the source if necessary.
-    if (pos + length > res->size()) {
-        res->resize(pos + length);
-    }
-
-    res->write(pos, length, source);
-    seek(length);
-}
-
-size_t Gosu::Buffer::size() const
-{
-    return buf.size();
-}
-
-void Gosu::Buffer::resize(size_t new_size)
-{
-    buf.resize(new_size);
-}
-
-void Gosu::Buffer::read(size_t offset, size_t length, void* dest_buffer) const
-{
-    assert (offset + length <= size());
-    if (length) {
-        memcpy(dest_buffer, &buf[offset], length);
-    }
-}
-
-void Gosu::Buffer::write(size_t offset, size_t length, const void* source_buffer)
-{
-    assert (offset + length <= size());
-    if (length) {
-        memcpy(&buf[offset], source_buffer, length);
-    }
-}
-
-void Gosu::load_file(Buffer& buffer, const string& filename)
-{
-    File file(filename);
-    buffer.resize(file.size());
-    file.read(0, buffer.size(), buffer.data());
-}
-
-void Gosu::save_file(const Buffer& buffer, const string& filename)
-{
-    File file(filename, FM_REPLACE);
-    file.write(0, buffer.size(), buffer.data());
-}

data/src/Iconv.hpp

@@ -1,51 +0,0 @@
-#pragma once
-
-#include <Gosu/Platform.hpp>
-
-#include <iconv.h>
-#include <errno.h>
-
-namespace Gosu
-{
-    template<typename Out, const char* to, const char* from, typename In>
-    Out iconvert(const In& in)
-    {
-        if (in.empty()) return Out();
-
-        const size_t buffer_len = 128;
-        typedef typename In::value_type InElem;
-        typedef typename Out::value_type OutElem;
-
-        static iconv_t cd = iconv_open(to, from);
-        
-        Out result;
-        OutElem buffer[buffer_len];
-        
-        char* inbuf = const_cast<char*>(reinterpret_cast<const char*>(&in[0]));
-        size_t inbytesleft = in.size() * sizeof(InElem);
-        char* outbuf = reinterpret_cast<char*>(buffer);
-        size_t outbytesleft = sizeof buffer;
-        
-        for (;;) {
-            size_t ret = ::iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
-            if (ret == static_cast<size_t>(-1) && errno == EILSEQ) {
-                // Skip illegal sequence part, repeat loop.
-                // TODO: Or retry w/ different encoding?
-                ++inbuf;
-                --inbytesleft;
-            }
-            else if (ret == static_cast<size_t>(-1) && errno == E2BIG) {
-                // Append new characters, reset out buffer, then repeat loop.
-                result.insert(result.end(), buffer, buffer + buffer_len);
-                outbuf = reinterpret_cast<char*>(buffer);
-                outbytesleft = sizeof buffer;
-            }
-            else {
-                // Append what's new in the buffer, then LEAVE loop.
-                result.insert(result.end(), buffer,
-                              buffer + buffer_len - outbytesleft / sizeof(OutElem));
-                return result;
-            }
-        }
-    }
-}

data/src/Inspection.cpp

@@ -1,27 +0,0 @@
-#include <Gosu/Inspection.hpp>
-#include <Gosu/Timing.hpp>
-
-namespace Gosu
-{
-    namespace FPS
-    {
-        int fps, accum;
-        unsigned long sec;
-
-        void register_frame()
-        {
-            ++accum;
-            unsigned long new_sec = Gosu::milliseconds() / 1000;
-            if (sec != new_sec) {
-                sec = new_sec;
-                fps = accum;
-                accum = 0;
-            }
-        }
-    }
-    
-    int fps()
-    {
-        return FPS::fps;
-    }
-}

data/src/LargeImageData.cpp

@@ -1,215 +0,0 @@
-#include "LargeImageData.hpp"
-#include <Gosu/Bitmap.hpp>
-#include <Gosu/Graphics.hpp>
-#include <Gosu/Math.hpp>
-#include <cmath>
-#include <stdexcept>
-
-const Gosu::ImageData& Gosu::LargeImageData::tile(int x, int y) const
-{
-    return *m_tiles.at(static_cast<std::size_t>(y * m_tiles_x + x));
-}
-
-Gosu::LargeImageData::LargeImageData(const Bitmap& source, int tile_width, int tile_height,
-                                     unsigned image_flags)
-{
-    m_w = source.width();
-    m_h = source.height();
-    // Manual ceil() for integer division.
-    m_tiles_x = (m_w + tile_width - 1) / tile_width;
-    m_tiles_y = (m_h + tile_height - 1) / tile_height;
-
-    // When there are no tiles, set both fields to 0 to avoid entering any for () loop in this class.
-    if (m_tiles_x == 0 || m_tiles_y == 0) {
-        m_tiles_x = m_tiles_y = 0;
-    }
-
-    m_tiles.reserve(m_tiles_x * m_tiles_y);
-
-    for (int y = 0; y < m_tiles_y; ++y) {
-        for (int x = 0; x < m_tiles_x; ++x) {
-            int src_width = tile_width;
-            if (x == m_tiles_x - 1 && m_w % tile_width != 0) {
-                // The right-most parts don't necessarily have the full width.
-                src_width = m_w % tile_width;
-            }
-
-            int src_height = tile_height;
-            if (y == m_tiles_y - 1 && m_h % tile_height != 0) {
-                // Same for the parts on the bottom.
-                src_height = m_h % tile_height;
-            }
-
-            unsigned local_flags = IF_TILEABLE | image_flags;
-
-            // Left edge, only tileable if requested in image_flags.
-            if (x == 0) {
-                local_flags &= ~IF_TILEABLE_LEFT;
-                local_flags |= (image_flags & IF_TILEABLE_LEFT);
-            }
-            // Right edge, only tileable if requested in image_flags.
-            if (x == m_tiles_x - 1) {
-                local_flags &= ~IF_TILEABLE_RIGHT;
-                local_flags |= (image_flags & IF_TILEABLE_RIGHT);
-            }
-            // Top edge, only tileable if requested in image_flags.
-            if (y == 0) {
-                local_flags &= ~IF_TILEABLE_TOP;
-                local_flags |= (image_flags & IF_TILEABLE_TOP);
-            }
-            // Bottom edge, only tileable if requested in image_flags.
-            if (y == m_tiles_y - 1) {
-                local_flags &= ~IF_TILEABLE_BOTTOM;
-                local_flags |= (image_flags & IF_TILEABLE_BOTTOM);
-            }
-
-            m_tiles.emplace_back(Graphics::create_image(source, x * tile_width, y * tile_height,
-                                                        src_width, src_height, local_flags));
-        }
-    }
-}
-
-void Gosu::LargeImageData::draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
-                                double x3, double y3, Color c3, double x4, double y4, Color c4,
-                                ZPos z, BlendMode mode) const
-{
-    normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
-
-    double y = 0;
-    for (int ty = 0; ty < m_tiles_y; ++ty) {
-        double x = 0;
-        for (int tx = 0; tx < m_tiles_x; ++tx) {
-            const ImageData& image = tile(tx, ty);
-
-            double rel_x_l = x / m_w;
-            double rel_x_r = (x + image.width()) / m_w;
-            double rel_y_t = y / m_h;
-            double rel_y_b = (y + image.height()) / m_h;
-
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define LERP2D(what, x_weight, y_weight)                                                           \
-    lerp(lerp(what##1, what##3, y_weight), lerp(what##2, what##4, y_weight), x_weight);
-
-            double x_t_l = LERP2D(x, rel_x_l, rel_y_t);
-            double x_t_r = LERP2D(x, rel_x_r, rel_y_t);
-            double x_b_l = LERP2D(x, rel_x_l, rel_y_b);
-            double x_b_r = LERP2D(x, rel_x_r, rel_y_b);
-
-            double y_t_l = LERP2D(y, rel_x_l, rel_y_t);
-            double y_t_r = LERP2D(y, rel_x_r, rel_y_t);
-            double y_b_l = LERP2D(y, rel_x_l, rel_y_b);
-            double y_b_r = LERP2D(y, rel_x_r, rel_y_b);
-
-            Color c_t_l = LERP2D(c, rel_x_l, rel_y_t);
-            Color c_t_r = LERP2D(c, rel_x_r, rel_y_t);
-            Color c_b_l = LERP2D(c, rel_x_l, rel_y_b);
-            Color c_b_r = LERP2D(c, rel_x_r, rel_y_b);
-
-            image.draw(x_t_l, y_t_l, c_t_l, x_t_r, y_t_r, c_t_r, x_b_l, y_b_l, c_b_l, x_b_r, y_b_r,
-                       c_b_r, z, mode);
-
-            x += image.width();
-        }
-        y += tile(0, ty).height();
-    }
-}
-
-std::unique_ptr<Gosu::ImageData> Gosu::LargeImageData::subimage(int left, int top, int width,
-                                                                int height) const
-{
-    if (left < 0 || top < 0 || left + width > m_w || top + height > m_h) {
-        throw std::invalid_argument{"subimage bounds exceed those of its parent"};
-    }
-    if (width <= 0 || height <= 0) {
-        throw std::invalid_argument{"cannot create empty subimage"};
-    }
-
-    int sub_tiles_y = 0;
-    std::vector<std::unique_ptr<ImageData>> sub_tiles;
-
-    int y = 0;
-    for (int ty = 0; ty < m_tiles_y; ++ty) {
-        int row_height = tile(0, ty).height();
-
-        if (y + row_height <= top) {
-            // Skip rows until we are at the requested Y coordinate.
-            y += row_height;
-            continue;
-        }
-        if (y >= top + height) {
-            // Also skip all rows after reaching the bottom requested Y coordinate.
-            break;
-        }
-
-        sub_tiles_y += 1;
-
-        int x = 0;
-        for (int tx = 0; tx < m_tiles_x; ++tx) {
-            const ImageData& image = tile(tx, ty);
-
-            if (x + image.width() <= left) {
-                // Skip columns until we are at the requested X coordinate.
-                x += image.width();
-                continue;
-            }
-            if (x >= left + width) {
-                // Also skip all columns after reaching the right-most requested Y coordinate.
-                break;
-            }
-
-            int sub_left = std::max(0, left - x);
-            int sub_top = std::max(0, top - y);
-            int sub_right = std::min(image.width(), left + width - x);
-            int sub_bottom = std::min(image.height(), top + height - y);
-
-            sub_tiles.emplace_back(
-                    image.subimage(sub_left, sub_top, sub_right - sub_left, sub_bottom - sub_top));
-
-            x += image.width();
-        }
-        y += tile(0, ty).height();
-    }
-
-    if (sub_tiles.size() == 1) {
-        return move(sub_tiles[0]);
-    }
-    else {
-        std::unique_ptr<LargeImageData> result(new LargeImageData());
-        result->m_w = width;
-        result->m_h = height;
-        result->m_tiles_x = static_cast<int>(sub_tiles.size()) / sub_tiles_y;
-        result->m_tiles_y = sub_tiles_y;
-        result->m_tiles.swap(sub_tiles);
-        return move(result);
-    }
-}
-
-Gosu::Bitmap Gosu::LargeImageData::to_bitmap() const
-{
-    Bitmap bitmap(width(), height());
-    int y = 0;
-    for (int ty = 0; ty < m_tiles_y; ++ty) {
-        int x = 0;
-        for (int tx = 0; tx < m_tiles_x; ++tx) {
-            const ImageData& image = tile(tx, ty);
-            bitmap.insert(x, y, image.to_bitmap());
-            x += image.width();
-        }
-        y += tile(0, ty).height();
-    }
-    return bitmap;
-}
-
-void Gosu::LargeImageData::insert(const Bitmap& bitmap, int at_x, int at_y)
-{
-    int y = 0;
-    for (int ty = 0; ty < m_tiles_y; ++ty) {
-        int x = 0;
-        for (int tx = 0; tx < m_tiles_x; ++tx) {
-            ImageData& image = *m_tiles[static_cast<std::size_t>(ty * m_tiles_x + tx)];
-            image.insert(bitmap, at_x - x, at_y - y);
-            x += image.width();
-        }
-        y += tile(0, ty).height();
-    }
-}

data/src/LargeImageData.hpp

@@ -1,39 +0,0 @@
-#pragma once
-
-#include <Gosu/Fwd.hpp>
-#include <Gosu/ImageData.hpp>
-#include <Gosu/Platform.hpp>
-#include "GraphicsImpl.hpp"
-#include <memory>
-#include <vector>
-
-class Gosu::LargeImageData : public Gosu::ImageData
-{
-    int m_w, m_h;
-    int m_tiles_x, m_tiles_y;
-    std::vector<std::unique_ptr<ImageData>> m_tiles;
-
-    LargeImageData() = default;
-
-    const ImageData& tile(int x, int y) const;
-
-public:
-    LargeImageData(const Bitmap& source, int tile_width, int tile_height, unsigned image_flags);
-
-    int width() const override { return m_w; }
-    int height() const override { return m_h; }
-
-    void draw(double x1, double y1, Color c1, //
-              double x2, double y2, Color c2, //
-              double x3, double y3, Color c3, //
-              double x4, double y4, Color c4, //
-              ZPos z, BlendMode mode) const override;
-
-    const GLTexInfo* gl_tex_info() const override { return nullptr; }
-
-    std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const override;
-
-    Bitmap to_bitmap() const override;
-
-    void insert(const Bitmap& bitmap, int x, int y) override;
-};

data/src/Log.hpp

@@ -1,19 +0,0 @@
-#pragma once
-
-#include <cstdio>
-#include <cstdlib>
-#include <utility>
-
-namespace Gosu
-{
-    template<class... Args>
-    void log(const char* format, Args&&... args)
-    {
-        // NOLINTNEXTLINE(concurrency-mt-unsafe) - we don't even follow the pointer
-        static bool enable_log = (std::getenv("GOSU_DEBUG") != nullptr);
-        if (enable_log) {
-            std::fprintf(stderr, format, std::forward<Args>(args)...);
-            std::fprintf(stderr, "\n");
-        }
-    }
-}