gosu 0.13.3 → 0.14.0.pre2

data/src/GraphicsImpl.hpp

@@ -4,21 +4,11 @@
 #include <Gosu/Graphics.hpp>
 #include <Gosu/Platform.hpp>
 
-#if defined(GOSU_IS_WIN)
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#include <windows.h>
-#include <GL/gl.h>
-#elif defined(GOSU_IS_IPHONE)
+#if defined(GOSU_IS_IPHONE) || defined(GOSU_IS_OPENGLES)
 #include <OpenGLES/ES1/gl.h>
 #include <OpenGLES/ES1/glext.h>
-#elif defined(GOSU_IS_MAC)
-#include <OpenGL/gl.h>
-#elif defined GOSU_IS_OPENGLES
-#include <GLES/gl.h>
 #else
-#include <GL/gl.h>
+#include <SDL_opengl.h>
 #endif
 
 #include <algorithm>
@@ -51,6 +41,13 @@ namespace Gosu
 
 namespace Gosu
 {
+    enum QueueMode
+    {
+        QM_RENDER_TO_SCREEN,
+        QM_RENDER_TO_TEXTURE,
+        QM_RECORD_MACRO,
+    };
+
     class Texture;
     class TexChunk;
     class ClipRectStack;
@@ -99,25 +96,11 @@ namespace Gosu
         y = out[1] / out[3];
     }
     
-    inline void multiply_bitmap_alpha(Bitmap& bmp, Color::Channel alpha)
-    {
-        for (int y = 0; y < bmp.height(); ++y) {
-            for (int x = 0; x < bmp.width(); ++x) {
-                Color c = bmp.get_pixel(x, y);
-                c.set_alpha(c.alpha() * alpha / 255);
-                bmp.set_pixel(x, y, c);
-            }
-        }
-    }
-    
-    #ifdef GOSU_IS_IPHONE
+#ifdef GOSU_IS_IPHONE
     int clip_rect_base_factor();
-    #else
+#else
     inline int clip_rect_base_factor() { return 1; }
-    #endif
-    
-    bool is_entity(const std::string& name);
-    const Bitmap& entity_bitmap(const std::string& name);
+#endif
     
     void ensure_current_context();
 }

data/src/Image.cpp

@@ -21,8 +21,8 @@ Gosu::Image::Image(const string& filename, unsigned flags)
     Image(bmp, flags).data_.swap(data_);
 }
 
-Gosu::Image::Image(const string& filename, unsigned src_x, unsigned src_y, unsigned src_width,
-    unsigned src_height, unsigned flags)
+Gosu::Image::Image(const string& filename, unsigned src_x, unsigned src_y,
+                   unsigned src_width, unsigned src_height, unsigned flags)
 {
     // Forward.
     Bitmap bmp;
@@ -36,8 +36,8 @@ Gosu::Image::Image(const Bitmap& source, unsigned flags)
     Image(source, 0, 0, source.width(), source.height(), flags).data_.swap(data_);
 }
 
-Gosu::Image::Image(const Bitmap& source, unsigned src_x, unsigned src_y, unsigned src_width,
-    unsigned src_height, unsigned flags)
+Gosu::Image::Image(const Bitmap& source, unsigned src_x, unsigned src_y,
+                   unsigned src_width, unsigned src_height, unsigned flags)
 : data_(Graphics::create_image(source, src_x, src_y, src_width, src_height, flags))
 {
 }
@@ -45,9 +45,7 @@ Gosu::Image::Image(const Bitmap& source, unsigned src_x, unsigned src_y, unsigne
 Gosu::Image::Image(unique_ptr<ImageData>&& data)
 : data_(data.release())
 {
-    if (this->data_.get() == nullptr) {
-        throw invalid_argument("Gosu::Image cannot be initialized with nullptr");
-    }
+    if (!data_) throw invalid_argument("Gosu::Image cannot be initialized with nullptr");
 }
 
 unsigned Gosu::Image::width() const

data/src/Input.cpp

@@ -79,19 +79,21 @@ struct Gosu::Input::Impl
         int x, y, window_x, window_y;
         SDL_GetWindowPosition(window, &window_x, &window_y);
         SDL_GetGlobalMouseState(&x, &y);
-        mouse_x = x - window_x, mouse_y = y - window_y;
+        mouse_x = x - window_x;
+        mouse_y = y - window_y;
     #else
         int x, y;
         SDL_GetMouseState(&x, &y);
-        mouse_x = x, mouse_y = y;
+        mouse_x = x;
+        mouse_y = y;
     #endif
     }
     
     void set_mouse_position(double x, double y)
     {
         SDL_WarpMouseInWindow(window,
-                              (x - mouse_offset_x) / mouse_scale_x,
-                              (y - mouse_offset_y) / mouse_scale_y);
+                              static_cast<int>((x - mouse_offset_x) / mouse_scale_x),
+                              static_cast<int>((y - mouse_offset_y) / mouse_scale_y));
 
     #if SDL_VERSION_ATLEAST(2, 0, 4) && !defined(GOSU_IS_X)
         // On systems where we have a working GetGlobalMouseState, we can warp the mouse and
@@ -329,7 +331,7 @@ string Gosu::Input::id_to_char(Button btn)
     // 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((int) wname[0]);
+    wname[0] = (wchar_t) towlower((wint_t) wname[0]);
     return wstring_to_utf8(wname);
 }
 

data/src/InputUIKit.cpp

@@ -7,19 +7,10 @@
 #import <UIKit/UIKit.h>
 using namespace std;
 
-struct Gosu::TextInput::Impl {};
-Gosu::TextInput::TextInput() {}
-Gosu::TextInput::~TextInput() {}
-string Gosu::TextInput::text() const { return ""; }
-void Gosu::TextInput::set_text(const string& text) {}
-unsigned Gosu::TextInput::caret_pos() const { return 0; }
-void Gosu::TextInput::set_caret_pos(unsigned) {}
-unsigned Gosu::TextInput::selection_start() const { return 0; }
-void Gosu::TextInput::set_selection_start(unsigned) {}
-
 struct Gosu::Input::Impl
 {
-    UIView* view;
+    UIView* view = nil;
+    TextInput* text_input = nullptr;
     float mouse_x, mouse_y;
     float scale_x, scale_y;
     float update_interval;
@@ -32,7 +23,7 @@ struct Gosu::Input::Impl
         CGPoint point = [ui_touch locationInView:view];
         
         return (Touch) {
-            .id = (__bridge void*) ui_touch,
+            .id = (__bridge void*)ui_touch,
             .x  = (float)point.x * scale_x,
             .y  = (float)point.y * scale_y,
         };
@@ -53,33 +44,22 @@ Gosu::Input::~Input()
 {
 }
 
-void Gosu::Input::feed_touch_event(int type, void* touches)
+void Gosu::Input::feed_touch_event(function<void (Touch)>& callback, void* touches)
 {
     NSSet* ui_touches = (__bridge NSSet*) touches;
     
     pimpl->current_touches_vector.reset();
     
-    function<void (Touch)>* callback = nullptr;
-    
-    if (type == 0) {
+    if (&callback == &on_touch_began) {
         [pimpl->current_touches_set unionSet:ui_touches];
-        callback = &on_touch_began;
-    }
-    else if (type == 1) {
-        callback = &on_touch_moved;
-    }
-    else if (type == 2) {
-        [pimpl->current_touches_set minusSet:ui_touches];
-        callback = &on_touch_ended;
     }
-    else if (type == 3) {
+    else if (&callback == &on_touch_ended || &callback == &on_touch_cancelled) {
         [pimpl->current_touches_set minusSet:ui_touches];
-        callback = &on_touch_cancelled;
     }
     
-    if (callback && *callback) {
+    if (callback) {
         for (UITouch* ui_touch in ui_touches) {
-            (*callback)(pimpl->translate_touch(ui_touch));
+            callback(pimpl->translate_touch(ui_touch));
         }
     }
 }
@@ -152,9 +132,7 @@ double Gosu::Input::accelerometer_z() const
 
 void Gosu::Input::update()
 {
-    // Check for dead touches and remove from vector if
-    // necessary
-
+    // Check for dead touches and remove from vector if necessary.
     NSMutableSet* dead_touches = nil;
 
     for (UITouch* touch in pimpl->current_touches_set) {
@@ -166,9 +144,7 @@ void Gosu::Input::update()
         }
         
         // Something was deleted, we will need the set.
-        if (!dead_touches) {
-            dead_touches = [NSMutableSet new];
-        }
+        if (!dead_touches) dead_touches = [NSMutableSet new];
         [dead_touches addObject:touch];
     }
     
@@ -187,12 +163,18 @@ void Gosu::Input::update()
 
 Gosu::TextInput* Gosu::Input::text_input() const
 {
-    return nullptr;
+    return pimpl->text_input;
 }
 
-void Gosu::Input::set_text_input(TextInput* input)
+void Gosu::Input::set_text_input(TextInput* text_input)
 {
-    throw "NYI";
+    if (text_input) {
+        pimpl->text_input = text_input;
+        [pimpl->view becomeFirstResponder];
+    } else {
+        [pimpl->view resignFirstResponder];
+        pimpl->text_input = nullptr;
+    }
 }
 
 #endif

data/src/Macro.cpp

@@ -1,5 +1,6 @@
 #include "Macro.hpp"
 #include "DrawOpQueue.hpp"
+#include <Gosu/Image.hpp>
 #include <cmath>
 #include <algorithm>
 #include <functional>
@@ -58,7 +59,8 @@ struct Gosu::Macro::Impl
         Float c[8];
         
         // Rows 1, 2
-        c[2] = x1, c[5] = y1;
+        c[2] = x1;
+        c[5] = y1;
         
         // The logic below assumes x2 != x4, i.e. row7 can be used to eliminate
         // the leftmost value in row 8 and afterwards the values in rows 3 & 4.
@@ -221,7 +223,13 @@ const Gosu::GLTexInfo* Gosu::Macro::gl_tex_info() const
 
 Gosu::Bitmap Gosu::Macro::to_bitmap() const
 {
-    throw logic_error("Gosu::Macro cannot be rendered as Gosu::Bitmap yet");
+    return Gosu::Graphics::render(pimpl->width, pimpl->height, [this] {
+        draw(0,            0,             Color::WHITE,
+             pimpl->width, 0,             Color::WHITE,
+             0,            pimpl->height, Color::WHITE,
+             pimpl->width, pimpl->height, Color::WHITE,
+             0, AM_DEFAULT);
+    }).data().to_bitmap();
 }
 
 unique_ptr<Gosu::ImageData> Gosu::Macro::subimage(int x, int y, int width, int height) const

data/src/MarkupParser.cpp

@@ -0,0 +1,241 @@
+#include "MarkupParser.hpp"
+#include <Gosu/Utility.hpp>
+#include "utf8proc.h"
+
+#include <cstring>
+using namespace std;
+
+// Helper method for allowing CJK text to have line breaks in the absence of whitespace.
+static bool should_allow_break_after_codepoint(utf8proc_int32_t cp)
+{
+    return (cp >= 0x3040 && cp <= 0x3096) || // Hiragana
+           (cp >= 0x30a0 && cp <= 0x30fa) || // Katakana
+           (cp >= 0x4e00 && cp <= 0x9fff) || // CJK Unified Ideographs
+           (cp >= 0x3400 && cp <= 0x4db5) || // CJK Unified Ideographs Extension A
+           (cp >= 0xac00 && cp <= 0xd7af);   // Precomposed Hangul syllables
+}
+
+unsigned Gosu::MarkupParser::flags() const
+{
+    unsigned flags = 0;
+    if (b > 0) flags |= Gosu::FF_BOLD;
+    if (i > 0) flags |= Gosu::FF_ITALIC;
+    if (u > 0) flags |= Gosu::FF_UNDERLINE;
+    return flags;
+}
+
+bool Gosu::MarkupParser::match_and_skip(const char* chars, size_t length)
+{
+    if (strncmp(markup, chars, length) != 0) return false;
+
+    // Finish building the current substring (if any) before matching.
+    add_current_substring();
+    // Skip chars.
+    markup += length;
+    return true;
+}
+
+bool Gosu::MarkupParser::parse_markup()
+{
+    // Open and close bold text spans.
+    if (match_and_skip("<b>")) {
+        b += 1;
+        return true;
+    }
+    if (match_and_skip("</b>")) {
+        b -= 1;
+        return true;
+    }
+
+    // Open and close underlined text spans.
+    if (match_and_skip("<u>")) {
+        u += 1;
+        return true;
+    }
+    if (match_and_skip("</u>")) {
+        u -= 1;
+        return true;
+    }
+
+    // Open and close italic text spans.
+    if (match_and_skip("<i>")) {
+        i += 1;
+        return true;
+    }
+    if (match_and_skip("</i>")) {
+        i -= 1;
+        return true;
+    }
+
+    // Reset to previous color.
+    if (match_and_skip("</c>")) {
+        if (c.size() > 1) {
+            c.pop_back();
+        }
+        else {
+            // If the user pops the color stack empty, go back to the default color.
+            c[0] = Color::WHITE;
+        }
+        return true;
+    }
+
+    // Leave the trickiest case for last - changing the current text color.
+    if (strncmp(markup, "<c=", 3) == 0) {
+        // Count hex chars following the <c= string.
+        const char* hex = markup + 3;
+        const char* valid_hex_chars = "0123456789ABCDEFabcdef";
+        size_t hex_chars = strspn(hex, valid_hex_chars);
+
+        if (*(hex + hex_chars) != '>' || (hex_chars != 3 && hex_chars != 6 && hex_chars != 8)) {
+            // Does not match <c=[0-9A-Fa-f]{3,6,8}> -> not considered valid markup.
+            return false;
+        }
+
+        add_current_substring();
+
+        auto argb = strtoul(hex, nullptr, 16);
+
+        if (hex_chars == 3) {
+            // Expand 0xrgb to 0xFFrrggbb:
+            auto r = argb >> 8 & 0x7;
+            auto g = argb >> 4 & 0x7;
+            auto b = argb >> 0 & 0x7;
+            argb = 0xff000000 | r << 20 | r << 16 | g << 12 | g << 8 | b << 4 | b << 0;
+        }
+        else if (hex_chars == 6) {
+            // Expand 0xrrggbb to 0xFFrrggbb:
+            argb = 0xff000000 | argb;
+        }
+
+        c.emplace_back(argb);
+
+        markup += (4 + hex_chars);
+        return true;
+    }
+
+    // Everything else is not considered markup.
+    return false;
+}
+
+bool Gosu::MarkupParser::parse_escape_entity()
+{
+    // These are not entities (images) but escapes for markup characters.
+    if (match_and_skip("&lt;")) {
+        add_composed_substring(u32string(1, '<'));
+        return true;
+    }
+    if (match_and_skip("&gt;")) {
+        add_composed_substring(u32string(1, '>'));
+        return true;
+    }
+    if (match_and_skip("&amp;")) {
+        add_composed_substring(u32string(1, '&'));
+        return true;
+    }
+
+    // These are the only recognized entities - disregard anything else.
+    return false;
+}
+
+void Gosu::MarkupParser::add_current_substring()
+{
+    if (!substring.empty()) {
+        add_composed_substring(utf8_to_composed_utc4(substring));
+        substring.clear();
+    }
+}
+
+void Gosu::MarkupParser::add_composed_substring(u32string&& substring)
+{
+    FormattedString fstr;
+    fstr.text = substring;
+    fstr.flags = flags();
+    fstr.color = c.back();
+
+    if (! substrings.empty() && substrings.back().can_be_merged_with(fstr)) {
+        substrings.back().text.append(move(fstr.text));
+    }
+    else {
+        substrings.emplace_back(move(fstr));
+    }
+}
+
+void Gosu::MarkupParser::flush_to_consumer()
+{
+    if (! substrings.empty()) {
+        consumer(move(substrings));
+        substrings.clear();
+    }
+}
+
+Gosu::MarkupParser::MarkupParser(const char* markup, unsigned base_flags, bool split_words,
+                                 function<void (vector<FormattedString>)> consumer)
+: markup(markup), consumer(move(consumer))
+{
+    word_state = (split_words ? ADDING_WORD : IGNORE_WORDS);
+
+    b = (base_flags & FF_BOLD)      ? 1 : 0;
+    i = (base_flags & FF_ITALIC)    ? 1 : 0;
+    u = (base_flags & FF_UNDERLINE) ? 1 : 0;
+}
+
+void Gosu::MarkupParser::parse()
+{
+    auto end_of_markup = markup + strlen(markup);
+    
+    while (markup < end_of_markup) {
+        if (*markup == '<' && parse_markup()) {
+            continue;
+        }
+        if (*markup == '&' && parse_escape_entity()) {
+            continue;
+        }
+
+        // The newline character always terminates the current line, regardless of whether this
+        // parser is trying to split words.
+        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.
+            ++markup;
+            add_current_substring();
+            flush_to_consumer();
+            // Avoid incrementing ++markup again.
+            continue;
+        }
+
+        utf8proc_int32_t codepoint;
+        auto len = utf8proc_iterate((utf8proc_uint8_t*) markup, end_of_markup - markup, &codepoint);
+        // Cancel parsing when invalid UTF-8 is encountered.
+        if (len < 1) break;
+        
+        auto* properties = utf8proc_get_property(codepoint);
+        // Also check the BiDi class to filter out non-breaking spaces.
+        bool whitespace_except_newline = properties->category == UTF8PROC_CATEGORY_ZS &&
+                                         properties->bidi_class == UTF8PROC_BIDI_CLASS_WS;
+
+        if (whitespace_except_newline && word_state == ADDING_WORD) {
+            // We are in word-parsing mode, and this is was the end of a word.
+            add_current_substring();
+            flush_to_consumer();
+            word_state = ADDING_WHITESPACE;
+        } else if (!whitespace_except_newline && word_state == ADDING_WHITESPACE) {
+            // We are in word-parsing mode, and this is was the start of a word.
+            add_current_substring();
+            flush_to_consumer();
+            word_state = ADDING_WORD;
+        }
+
+        substring.append(markup, len);
+        markup += len;
+        
+        if (word_state != IGNORE_WORDS && should_allow_break_after_codepoint(codepoint)) {
+            // Flush each individual CJK character out as a word so that the TextBuilder can insert
+            // line breaks as needed.
+            add_current_substring();
+            flush_to_consumer();
+        }
+    }
+
+    add_current_substring();
+    flush_to_consumer();
+}