gosu 0.14.0.pre2 → 0.14.0

data/src/DrawOpQueue.hpp

@@ -13,9 +13,10 @@
 
 class Gosu::DrawOpQueue
 {
+    const QueueMode queue_mode;
+
     TransformStack transform_stack;
     ClipRectStack clip_rect_stack;
-    QueueMode queue_mode = QM_RENDER_TO_SCREEN;
 
     std::vector<DrawOp> ops;
     std::vector<std::function<void ()>> gl_blocks;

data/src/FileWin.cpp

@@ -1,88 +1,88 @@
-#include <Gosu/Platform.hpp>
-#if defined(GOSU_IS_WIN)
-
-#include "WinUtility.hpp"
-#include <Gosu/IO.hpp>
-#include <Gosu/Utility.hpp>
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_WIN)
+
+#include "WinUtility.hpp"
+#include <Gosu/IO.hpp>
+#include <Gosu/Utility.hpp>
 #include <windows.h>
-using namespace std;
-
-// TODO: Error checking
-
-struct Gosu::File::Impl
-{
-    HANDLE handle = INVALID_HANDLE_VALUE;
-
-    ~Impl()
-    {
-        if (handle != INVALID_HANDLE_VALUE) {
-            CloseHandle(handle);
-        }
-    }
-};
-
-Gosu::File::File(const string& filename, FileMode mode)
-: pimpl(new Impl)
-{
-    DWORD access;
-    switch (mode) {
-    case FM_READ:
-        access = GENERIC_READ;
-        break;
-    case FM_REPLACE:
-        access = GENERIC_WRITE;
-        break;
-    case FM_ALTER:
-        access = GENERIC_READ | GENERIC_WRITE;
-        break;
-    }
-    DWORD share_mode = FILE_SHARE_READ;
-    DWORD creation_disp = (mode == FM_READ) ? OPEN_EXISTING : OPEN_ALWAYS;
-
-    wstring wfilename = utf8_to_wstring(filename);
-    pimpl->handle = CreateFileW(wfilename.c_str(), access, share_mode, 0, creation_disp,
-                                FILE_ATTRIBUTE_NORMAL, 0);
-    if (pimpl->handle == INVALID_HANDLE_VALUE) {
-        throw_last_winapi_error("opening " + filename);
-    }
-    if (mode == FM_REPLACE) {
-        resize(0);
-    }
-}
-
-Gosu::File::~File()
-{
-}
-
-size_t Gosu::File::size() const
-{
-    return GetFileSize(pimpl->handle, 0);
-}
-
-void Gosu::File::resize(size_t new_size)
-{
-    if (SetFilePointer(pimpl->handle, new_size, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
-        throw_last_winapi_error("setting the file pointer");
-    }
-    winapi_check(SetEndOfFile(pimpl->handle), "resizing a file");
-}
-
-void Gosu::File::read(size_t offset, size_t length, void* dest_buffer) const
-{
-    if (SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
-        throw_last_winapi_error("setting the file pointer");
-    }
-    DWORD dummy;
-    winapi_check(ReadFile(pimpl->handle, dest_buffer, length, &dummy, 0));
-}
-
-void Gosu::File::write(size_t offset, size_t length, const void* source_buffer)
-{
-    if (SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
-        throw_last_winapi_error("setting the file pointer");
-    }
-    DWORD dummy;
-    winapi_check(WriteFile(pimpl->handle, source_buffer, length, &dummy, 0));
-}
-
-#endif
+using namespace std;
+
+// TODO: Error checking
+
+struct Gosu::File::Impl
+{
+    HANDLE handle = INVALID_HANDLE_VALUE;
+
+    ~Impl()
+    {
+        if (handle != INVALID_HANDLE_VALUE) {
+            CloseHandle(handle);
+        }
+    }
+};
+
+Gosu::File::File(const string& filename, FileMode mode)
+: pimpl(new Impl)
+{
+    DWORD access;
+    switch (mode) {
+    case FM_READ:
+        access = GENERIC_READ;
+        break;
+    case FM_REPLACE:
+        access = GENERIC_WRITE;
+        break;
+    case FM_ALTER:
+        access = GENERIC_READ | GENERIC_WRITE;
+        break;
+    }
+    DWORD share_mode = FILE_SHARE_READ;
+    DWORD creation_disp = (mode == FM_READ) ? OPEN_EXISTING : OPEN_ALWAYS;
+
+    wstring wfilename = utf8_to_utf16(filename);
+    pimpl->handle = CreateFileW(wfilename.c_str(), access, share_mode, 0, creation_disp,
+                                FILE_ATTRIBUTE_NORMAL, 0);
+    if (pimpl->handle == INVALID_HANDLE_VALUE) {
+        throw_last_winapi_error("opening " + filename);
+    }
+    if (mode == FM_REPLACE) {
+        resize(0);
+    }
+}
+
+Gosu::File::~File()
+{
+}
+
+size_t Gosu::File::size() const
+{
+    return GetFileSize(pimpl->handle, 0);
+}
+
+void Gosu::File::resize(size_t new_size)
+{
+    if (SetFilePointer(pimpl->handle, new_size, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
+        throw_last_winapi_error("setting the file pointer");
+    }
+    winapi_check(SetEndOfFile(pimpl->handle), "resizing a file");
+}
+
+void Gosu::File::read(size_t offset, size_t length, void* dest_buffer) const
+{
+    if (SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
+        throw_last_winapi_error("setting the file pointer");
+    }
+    DWORD dummy;
+    winapi_check(ReadFile(pimpl->handle, dest_buffer, length, &dummy, 0));
+}
+
+void Gosu::File::write(size_t offset, size_t length, const void* source_buffer)
+{
+    if (SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
+        throw_last_winapi_error("setting the file pointer");
+    }
+    DWORD dummy;
+    winapi_check(WriteFile(pimpl->handle, source_buffer, length, &dummy, 0));
+}
+
+#endif

data/src/Font.cpp

@@ -27,10 +27,10 @@ struct Gosu::Font::Impl
     // Everything else is looked up through a map...
     array<map<utf8proc_int32_t, Image>, FF_COMBINATIONS> other_glyphs;
     
-    const Image& image(char32_t codepoint, unsigned font_flags)
+    Image& image(char32_t codepoint, unsigned font_flags)
     {
         Image* image;
-        if (codepoint < fast_glyphs.size()) {
+        if (codepoint < fast_glyphs[font_flags].size()) {
             image = &fast_glyphs[font_flags][codepoint];
         }
         else {
@@ -43,13 +43,13 @@ struct Gosu::Font::Impl
             
             u32string string(1, codepoint);
             Bitmap bitmap(scaled_height, scaled_height);
-            auto required_width = ceil(draw_text(bitmap, 0, 0, Color::WHITE, string,
-                                                 name, scaled_height, font_flags));
+            auto required_width = ceil(Gosu::draw_text(bitmap, 0, 0, Color::WHITE, string,
+                                                       name, scaled_height, font_flags));
             if (required_width > bitmap.width()) {
                 // If the character was wider than high, we need to render it again.
                 Bitmap(required_width, scaled_height).swap(bitmap);
-                draw_text(bitmap, 0, 0, Color::WHITE, string,
-                          name, scaled_height, font_flags);
+                Gosu::draw_text(bitmap, 0, 0, Color::WHITE, string,
+                                name, scaled_height, font_flags);
             }
             
             *image = Image(bitmap, 0, 0, required_width, scaled_height);
@@ -82,60 +82,79 @@ unsigned Gosu::Font::flags() const
     return pimpl->base_flags;
 }
 
-double Gosu::Font::text_width(const string& text, double scale_x) const
+double Gosu::Font::text_width(const string& text) const
 {
-    int width = 0;
+    return markup_width(escape_markup(text));
+}
+
+double Gosu::Font::markup_width(const string& markup) const
+{
+    double width = 0;
 
     // Split the text into lines (split_words = false) because Font doesn't implement word-wrapping.
-    MarkupParser(text.c_str(), pimpl->base_flags, false, [&](vector<FormattedString>&& line) {
-        int line_width = 0;
+    MarkupParser parser(pimpl->base_flags, false, [&](vector<FormattedString>&& line) {
+        double line_width = 0;
         for (auto& part : line) {
             for (auto codepoint : part.text) {
-                line_width += pimpl->image(codepoint, part.flags).width();
+                auto& image = pimpl->image(codepoint, part.flags);
+                double image_scale = 1.0 * height() / image.height();
+                line_width += image_scale * image.width();
             }
         }
         width = max(width, line_width);
-    }).parse();
+    });
+    parser.parse(markup);
     
-    return scale_x * width / FONT_RENDER_SCALE;
+    return width;
+}
+
+void Gosu::Font::draw_text(const string& text, double x, double y, ZPos z,
+                           double scale_x, double scale_y, Color c, AlphaMode mode) const
+{
+    draw_markup(escape_markup(text), x, y, z, scale_x, scale_y, c, mode);
 }
 
-void Gosu::Font::draw(const string& text, double x, double y, ZPos z,
-    double scale_x, double scale_y, Color c, AlphaMode mode) const
+void Gosu::Font::draw_markup(const string& markup, double x, double y, ZPos z,
+                             double scale_x, double scale_y, Color c, AlphaMode mode) const
 {
     double current_y = y;
     
     // Split the text into lines (split_words = false) because Font doesn't implement word-wrapping.
-    MarkupParser(text.c_str(), pimpl->base_flags, false, [&](vector<FormattedString>&& line) {
+    MarkupParser parser(pimpl->base_flags, false, [&](vector<FormattedString>&& line) {
         double current_x = x;
         for (auto& part : line) {
             for (auto codepoint : part.text) {
                 auto& image = pimpl->image(codepoint, part.flags);
+                double image_scale = 1.0 * height() / image.height();
                 image.draw(current_x, current_y, z,
-                           scale_x / FONT_RENDER_SCALE, scale_y / FONT_RENDER_SCALE,
-                           c, mode);
-                current_x += scale_x * image.width() / FONT_RENDER_SCALE;
+                           image_scale * scale_x, image_scale * scale_y,
+                           multiply(c, part.color), mode);
+                current_x += image_scale * scale_x * image.width();
             }
         }
         current_y += scale_y * height();
-    }).parse();
+    });
+    parser.parse(markup);
 }
 
-void Gosu::Font::draw_rel(const string& text, double x, double y, ZPos z,
-    double rel_x, double rel_y, double scale_x, double scale_y, Color c, AlphaMode mode) const
+void Gosu::Font::draw_text_rel(const string& text, double x, double y, ZPos z,
+                               double rel_x, double rel_y, double scale_x, double scale_y,
+                               Color c, AlphaMode mode) const
 {
-    x -= text_width(text) * scale_x * rel_x;
-    y -= height() * scale_y * rel_y;
+    if (rel_x) x -= text_width(text) * scale_x * rel_x;
+    if (rel_y) y -= height() * scale_y * rel_y;
     
-    draw(text, x, y, z, scale_x, scale_y, c, mode);
+    draw_text(text, x, y, z, scale_x, scale_y, c, mode);
 }
 
-void Gosu::Font::draw_rot(const string& text, double x, double y, ZPos z, double angle,
-    double scale_x, double scale_y, Color c, AlphaMode mode) const
+void Gosu::Font::draw_markup_rel(const string& markup, double x, double y, ZPos z,
+                                 double rel_x, double rel_y, double scale_x, double scale_y,
+                                 Color c, AlphaMode mode) const
 {
-    Graphics::transform(rotate(angle, x, y), [&] {
-        draw(text, x, y, z, scale_x, scale_y, c, mode);
-    });
+    if (rel_x) x -= markup_width(markup) * scale_x * rel_x;
+    if (rel_y) y -= height() * scale_y * rel_y;
+    
+    draw_markup(markup, x, y, z, scale_x, scale_y, c, mode);
 }
 
 void Gosu::Font::set_image(std::string codepoint, unsigned font_flags, const Gosu::Image& image)
@@ -147,7 +166,8 @@ void Gosu::Font::set_image(std::string codepoint, unsigned font_flags, const Gos
     
     if (utc4[0] < pimpl->fast_glyphs[font_flags].size()) {
         pimpl->fast_glyphs[font_flags][utc4[0]] = image;
-    } else {
+    }
+    else {
         pimpl->other_glyphs[font_flags][utc4[0]] = image;
     }
 }

data/src/Graphics.cpp

@@ -288,7 +288,7 @@ Gosu::Image Gosu::Graphics::render(int width, int height, const function<void ()
     Image result = OffScreenTarget(width, height).render([&] {
         glClearColor(0, 0, 0, 0);
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-        queues.emplace_back(QM_RENDER_TO_SCREEN);
+        queues.emplace_back(QM_RENDER_TO_TEXTURE);
         f();
         queues.back().perform_draw_ops_and_code();
         queues.pop_back();

data/src/GraphicsImpl.hpp

@@ -8,6 +8,7 @@
 #include <OpenGLES/ES1/gl.h>
 #include <OpenGLES/ES1/glext.h>
 #else
+#include <SDL.h>
 #include <SDL_opengl.h>
 #endif
 
@@ -102,5 +103,23 @@ namespace Gosu
     inline int clip_rect_base_factor() { return 1; }
 #endif
     
+#ifndef GOSU_IS_IPHONE
+    SDL_Window* shared_window();
+#endif
+    
     void ensure_current_context();
+    
+    inline std::string escape_markup(const std::string& text) {
+        // Escape all markup and delegate to layout_markup.
+        auto markup = text;
+        for (std::string::size_type pos = 0; pos < markup.length(); ++pos) {
+            if (markup[pos] == '&') {
+                markup.replace(pos, 1, "&amp;");
+            }
+            else if (markup[pos] == '<') {
+                markup.replace(pos, 1, "&lt;");
+            }
+        }
+        return markup;
+    }
 }

data/src/Input.cpp

@@ -4,13 +4,22 @@
 #include <Gosu/Input.hpp>
 #include <Gosu/TextInput.hpp>
 #include <Gosu/Utility.hpp>
+
 #include <SDL.h>
+#include "utf8proc.h"
+
 #include <cwctype>
 #include <cstdlib>
 #include <algorithm>
 #include <array>
 using namespace std;
 
+// Workaround for broken SDL_GetGlobalMouseState, see below.
+#ifdef GOSU_IS_MAC
+#import <CoreGraphics/CoreGraphics.h>
+#import <AppKit/AppKit.h>
+#endif
+
 static void require_sdl_video()
 {
     static bool initialized = false;
@@ -71,11 +80,17 @@ struct Gosu::Input::Impl
     
     void update_mouse_position()
     {
-    // Do not use GetGlobalMouseState on Linux for now to prevent this bug:
-    // https://github.com/gosu/gosu/issues/326
-    // Once SDL 2.0.5 has been released, we can use this function as a workaround:
-    // https://wiki.libsdl.org/SDL_GetWindowBordersSize
-    #if SDL_VERSION_ATLEAST(2, 0, 4) && !defined(GOSU_IS_X)
+    #if defined(GOSU_IS_MAC)
+        // Avoid SDL_GetGlobalMouseState on macOS until this bug is fixed:
+        // https://bugzilla.libsdl.org/show_bug.cgi?id=4255
+        int window_x, window_y;
+        SDL_GetWindowPosition(window, &window_x, &window_y);
+        auto mouse_position = NSEvent.mouseLocation;
+        mouse_x = mouse_position.x - window_x;
+        mouse_y = (CGDisplayPixelsHigh(kCGDirectMainDisplay) - mouse_position.y) - window_y;
+    #elif SDL_VERSION_ATLEAST(2, 0, 5)
+        // SDL_GetGlobalMouseState was added in SDL 2.0.4, but it only started using the same
+        // coordinate system as SDL_GetWindowPosition on X11 in 2.0.5.
         int x, y, window_x, window_y;
         SDL_GetWindowPosition(window, &window_x, &window_y);
         SDL_GetGlobalMouseState(&x, &y);
@@ -325,14 +340,17 @@ string Gosu::Input::id_to_char(Button btn)
     const char* name = SDL_GetKeyName(keycode);
     if (name == nullptr) return "";
     
-    wstring wname = utf8_to_wstring(name);
-    if (wname.length() != 1) return "";
+    u32string codepoints = utf8_to_composed_utc4(name);
+    
+    // Filter out names that are more than one logical character.
+    if (codepoints.length() != 1) return "";
     
-    // Convert to lower case to be consistent with previous versions of Gosu.
-    // German umlauts are already reported in lower-case by SDL, anyway.
-    // (This should handle Turkish i/I just fine because it uses the current locale.)
-    wname[0] = (wchar_t) towlower((wint_t) wname[0]);
-    return wstring_to_utf8(wname);
+    // Always return lower case to be consistent with previous versions of Gosu.
+    codepoints[0] = utf8proc_tolower(codepoints[0]);
+    // Convert back to UTF-8.
+    utf8proc_uint8_t utf8_buffer[4];
+    auto len = utf8proc_encode_char(codepoints[0], utf8_buffer);
+    return string(reinterpret_cast<char*>(utf8_buffer), len);
 }
 
 Gosu::Button Gosu::Input::char_to_id(string ch)

data/src/MarkupParser.cpp

@@ -97,9 +97,9 @@ bool Gosu::MarkupParser::parse_markup()
 
         if (hex_chars == 3) {
             // Expand 0xrgb to 0xFFrrggbb:
-            auto r = argb >> 8 & 0x7;
-            auto g = argb >> 4 & 0x7;
-            auto b = argb >> 0 & 0x7;
+            auto r = argb >> 8 & 0xf;
+            auto g = argb >> 4 & 0xf;
+            auto b = argb >> 0 & 0xf;
             argb = 0xff000000 | r << 20 | r << 16 | g << 12 | g << 8 | b << 4 | b << 0;
         }
         else if (hex_chars == 6) {
@@ -139,7 +139,7 @@ bool Gosu::MarkupParser::parse_escape_entity()
 
 void Gosu::MarkupParser::add_current_substring()
 {
-    if (!substring.empty()) {
+    if (! substring.empty()) {
         add_composed_substring(utf8_to_composed_utc4(substring));
         substring.clear();
     }
@@ -168,9 +168,9 @@ void Gosu::MarkupParser::flush_to_consumer()
     }
 }
 
-Gosu::MarkupParser::MarkupParser(const char* markup, unsigned base_flags, bool split_words,
+Gosu::MarkupParser::MarkupParser(unsigned base_flags, bool split_words,
                                  function<void (vector<FormattedString>)> consumer)
-: markup(markup), consumer(move(consumer))
+: consumer(move(consumer))
 {
     word_state = (split_words ? ADDING_WORD : IGNORE_WORDS);
 
@@ -179,9 +179,10 @@ Gosu::MarkupParser::MarkupParser(const char* markup, unsigned base_flags, bool s
     u = (base_flags & FF_UNDERLINE) ? 1 : 0;
 }
 
-void Gosu::MarkupParser::parse()
+void Gosu::MarkupParser::parse(const std::string& markup_string)
 {
-    auto end_of_markup = markup + strlen(markup);
+    markup = markup_string.data();
+    const char* end_of_markup = markup_string.data() + markup_string.length();
     
     while (markup < end_of_markup) {
         if (*markup == '<' && parse_markup()) {
@@ -196,7 +197,9 @@ void Gosu::MarkupParser::parse()
         if (*markup == '\n') {
             // Explicitly add the trailing \n to the current substring so that the consumer can
             // distinguish between line breaks and word breaks in split_words mode.
+            substring.append(1, '\n');
             ++markup;
+            
             add_current_substring();
             flush_to_consumer();
             // Avoid incrementing ++markup again.