gosu 0.13.3 → 0.14.0.pre2

data/src/TextBuilder.cpp

@@ -0,0 +1,138 @@
+#include "TextBuilder.hpp"
+#include <Gosu/Text.hpp>
+#include <cassert>
+#include <cmath>
+#include "utf8proc.h"
+using namespace std;
+
+Gosu::WordInfo::WordInfo(const string& font_name, double font_height, vector<FormattedString> parts)
+{
+    assert (! parts.empty());
+    
+    auto* properties = utf8proc_get_property(parts.front().text.front());
+
+    // Also check the BiDi class to filter out non-breaking spaces.
+    is_whitespace = properties->category == UTF8PROC_CATEGORY_ZS &&
+                    properties->bidi_class == UTF8PROC_BIDI_CLASS_WS;
+
+    is_end_of_line = parts.back().text.back() == '\n';
+    // Remove the trailing backspace character to avoid errors from Gosu::text_width().
+    if (is_end_of_line) parts.back().text.pop_back();
+    
+    width = 0;
+    for (const auto& part : parts) {
+        assert (! part.text.empty());
+        
+        width += text_width(part.text, font_name, font_height, part.flags);
+    }
+    
+    this->parts = move(parts);
+}
+
+void Gosu::TextBuilder::flush_current_line(EndOfLineReason reason)
+{
+    if (current_line.empty()) {
+        if (reason == END_OF_PARAGRAPH) allocate_next_line();
+        return;
+    }
+    
+    allocate_next_line();
+    
+    // Remove trailing whitespace so that justifying the text across the line works.
+    if (current_line.back().is_whitespace) current_line.pop_back();
+    
+    // Shouldn't happen because the first word on a line should never be whitespace.
+    assert (! current_line.empty());
+    
+    double words_width = 0, whitespace_width = 0;
+    for (const auto& word : current_line) {
+        (word.is_whitespace ? whitespace_width : words_width) += word.width;
+    }
+    
+    double x = 0;
+    if (align == AL_RIGHT) {
+        x = result.width() - words_width - whitespace_width;
+    }
+    else if (align == AL_CENTER) {
+        x = (result.width() - words_width - whitespace_width) / 2.0;
+    }
+    
+    double whitespace_factor = 1.0;
+    if (align == AL_JUSTIFY && reason == LINE_TOO_LONG) {
+        whitespace_factor = (result.width() - words_width) / whitespace_width;
+    }
+    
+    double y = (used_lines - 1) * (font_height + line_spacing);
+    
+    for (const auto& word : current_line) {
+        if (word.is_whitespace) {
+            x += word.width * whitespace_factor;
+        }
+        else {
+            for (const auto& part : word.parts) {
+                draw_text(result, x, y, part.color, part.text, font_name, font_height, part.flags);
+            }
+            x += word.width;
+        }
+    }
+    
+    current_line.clear();
+    current_line_width = 0;
+}
+
+void Gosu::TextBuilder::allocate_next_line()
+{
+    if (used_lines == allocated_lines) {
+        allocated_lines += 10;
+        resize_to_allocated_lines();
+    }
+    
+    ++used_lines;
+}
+
+void Gosu::TextBuilder::resize_to_allocated_lines()
+{
+    double new_height = font_height * allocated_lines + line_spacing * max(0, allocated_lines - 1);
+    result.resize(result.width(), ceil(new_height));
+}
+
+Gosu::TextBuilder::TextBuilder(const string& font_name, int font_height, int line_spacing,
+                               int width, Alignment align)
+: font_name(font_name), font_height(font_height), line_spacing(line_spacing), align(align)
+{
+    // This class uses result.width() to remember its destination width, so store it in there.
+    result.resize(width, 0);
+}
+
+Gosu::Bitmap Gosu::TextBuilder::move_into_bitmap()
+{
+    flush_current_line(END_OF_TEXT);
+    
+    // Shrink to fit the currently used height.
+    allocated_lines = used_lines;
+    resize_to_allocated_lines();
+    return move(result);
+}
+
+void Gosu::TextBuilder::feed_word(vector<FormattedString>&& word)
+{
+    WordInfo new_word(font_name, font_height, word);
+    
+    if (current_line_width + new_word.width > result.width()) {
+        // Can't fit it on the same line as before, so flush the last line before adding the word to
+        // the next line.
+        flush_current_line(LINE_TOO_LONG);
+        
+        if (new_word.is_whitespace) {
+            // Do not wrap trailing whitespace onto the start of the next line - discard this word.
+            return;
+        }
+    }
+    
+    current_line.emplace_back(new_word);
+    current_line_width += new_word.width;
+
+    if (current_line_width > result.width() || new_word.is_end_of_line) {
+        flush_current_line(new_word.is_end_of_line ? END_OF_PARAGRAPH : LINE_TOO_LONG);
+    }
+}

data/src/TextBuilder.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "GraphicsImpl.hpp"
+#include "MarkupParser.hpp"
+#include <vector>
+
+namespace Gosu
+{
+    struct WordInfo
+    {
+        std::vector<FormattedString> parts;
+        bool is_whitespace;
+        bool is_end_of_line;
+        double width;
+        
+        WordInfo(const std::string& font_name, double font_height,
+                 std::vector<FormattedString> parts);
+    };
+    
+    class TextBuilder
+    {
+        // Parameters.
+        std::string font_name;
+        double font_height;
+        double line_spacing;
+        Alignment align;
+        
+        enum EndOfLineReason {
+            LINE_TOO_LONG,
+            END_OF_PARAGRAPH,
+            END_OF_TEXT
+        };
+        
+        // Input.
+        std::vector<WordInfo> current_line;
+        int current_line_width = 0;
+        void flush_current_line(EndOfLineReason reason);
+
+        // Output.
+        Bitmap result;
+        int used_lines = 0;
+        int allocated_lines = 0;
+        void allocate_next_line();
+        void resize_to_allocated_lines();
+        
+    public:
+        TextBuilder(const std::string& font_name, int font_height, int line_spacing,
+                    int width, Alignment align);
+        
+        void feed_word(std::vector<FormattedString>&& word);
+
+        Bitmap move_into_bitmap();
+    };
+}
+

data/src/TextInput.cpp

@@ -1,18 +1,19 @@
-#include <Gosu/Platform.hpp>
-#if !defined(GOSU_IS_IPHONE)
-
 #include <Gosu/TextInput.hpp>
 #include <Gosu/Input.hpp>
 #include <Gosu/Platform.hpp>
+
+#ifndef GOSU_IS_IPHONE
 #include <SDL.h>
 #include <cctype>
+#endif
+
 using namespace std;
 
 struct Gosu::TextInput::Impl
 {
     string text;
     
-    // This is the current IME composition.
+    // This is the current IME composition (not used on iOS).
     // http://wiki.libsdl.org/Tutorials/TextInput#CandidateList
     string composition;
     
@@ -152,6 +153,7 @@ Gosu::TextInput::TextInput()
 
 Gosu::TextInput::~TextInput()
 {
+    // TODO: Unset Input::text_input to avoid stale pointers?
 }
 
 string Gosu::TextInput::text() const
@@ -172,12 +174,12 @@ void Gosu::TextInput::set_text(const string& text)
 
 unsigned Gosu::TextInput::caret_pos() const
 {
-    return static_cast<unsigned>(pimpl->caret_pos);
+    return pimpl->caret_pos;
 }
 
-void Gosu::TextInput::set_caret_pos(unsigned pos)
+void Gosu::TextInput::set_caret_pos(unsigned caret_pos)
 {
-    pimpl->caret_pos = pos;
+    pimpl->caret_pos = caret_pos;
 }
 
 unsigned Gosu::TextInput::selection_start() const
@@ -185,11 +187,12 @@ unsigned Gosu::TextInput::selection_start() const
     return pimpl->selection_start;
 }
 
-void Gosu::TextInput::set_selection_start(unsigned pos)
+void Gosu::TextInput::set_selection_start(unsigned selection_start)
 {
-    pimpl->selection_start = pos;
+    pimpl->selection_start = selection_start;
 }
 
+#ifndef GOSU_IS_IPHONE
 bool Gosu::TextInput::feed_sdl_event(void* event)
 {
     const SDL_Event* e = static_cast<SDL_Event*>(event);
@@ -275,5 +278,19 @@ bool Gosu::TextInput::feed_sdl_event(void* event)
     
     return false;
 }
-
 #endif
+
+void Gosu::TextInput::insert_text(string text)
+{
+    pimpl->insert_text(text);
+}
+
+void Gosu::TextInput::delete_forward()
+{
+    pimpl->delete_forward();
+}
+
+void Gosu::TextInput::delete_backward()
+{
+    pimpl->delete_backward();
+}

data/src/Texture.cpp

@@ -11,16 +11,14 @@ namespace Gosu
     bool undocumented_retrofication = false;
 }
 
-Gosu::Texture::Texture(unsigned size, bool retro)
-: allocator_(size, size), retro_(retro)
+Gosu::Texture::Texture(unsigned width, unsigned height, bool retro)
+: allocator_(width, height), retro_(retro)
 {
     ensure_current_context();
     
     // Create texture name.
     glGenTextures(1, &tex_name_);
-    if (tex_name_ == static_cast<GLuint>(-1)) {
-        throw runtime_error("Couldn't create OpenGL texture");
-    }
+    if (tex_name_ == static_cast<GLuint>(-1)) throw runtime_error("Couldn't create OpenGL texture");
 
     // Create empty texture.
     glBindTexture(GL_TEXTURE_2D, tex_name_);
@@ -57,9 +55,14 @@ Gosu::Texture::~Texture()
     glDeleteTextures(1, &tex_name_);
 }
 
-unsigned Gosu::Texture::size() const
+unsigned Gosu::Texture::width() const
+{
+    return allocator_.width();
+}
+
+unsigned Gosu::Texture::height() const
 {
-    return allocator_.width(); // == height
+    return allocator_.height();
 }
 
 GLuint Gosu::Texture::tex_name() const
@@ -72,19 +75,18 @@ bool Gosu::Texture::retro() const
     return retro_;
 }
 
-unique_ptr<Gosu::TexChunk> Gosu::Texture::try_alloc(shared_ptr<Texture> ptr, const Bitmap& bmp,
-                                                    unsigned padding)
+unique_ptr<Gosu::TexChunk> Gosu::Texture::try_alloc(const Bitmap& bmp, unsigned padding)
 {
     BlockAllocator::Block block;
     
     if (!allocator_.alloc(bmp.width(), bmp.height(), block)) return nullptr;
     
-    unique_ptr<Gosu::TexChunk> result(new TexChunk(ptr,
-                                                   block.left + padding,
-                                                   block.top + padding,
-                                                   block.width - 2 * padding,
-                                                   block.height - 2 * padding,
-                                                   padding));
+    unique_ptr<TexChunk> result(new TexChunk(shared_from_this(),
+                                             block.left   + padding,
+                                             block.top    + padding,
+                                             block.width  - 2 * padding,
+                                             block.height - 2 * padding,
+                                             padding));
     
     ensure_current_context();
     
@@ -108,14 +110,17 @@ void Gosu::Texture::free(unsigned x, unsigned y, unsigned width, unsigned height
 Gosu::Bitmap Gosu::Texture::to_bitmap(unsigned x, unsigned y, unsigned width, unsigned height) const
 {
 #ifdef GOSU_IS_OPENGLES
+    // See here for one possible implementation: https://github.com/apitrace/apitrace/issues/70
+    // (Could reuse a lot of code from OffScreenTarget)
     throw logic_error("Texture::to_bitmap not supported on iOS");
 #else
     ensure_current_context();
     
-    Gosu::Bitmap full_texture(size(), size());
+    Bitmap full_texture(this->width(), this->height());
     glBindTexture(GL_TEXTURE_2D, tex_name());
+    // TODO: There are ways to retrieve only part of a texture, which we should use sooner or later.
     glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, full_texture.data());
-    Gosu::Bitmap bitmap(width, height);
+    Bitmap bitmap(width, height);
     bitmap.insert(full_texture, -int(x), -int(y));
     
     return bitmap;

data/src/Texture.hpp

@@ -5,26 +5,25 @@
 #include "TexChunk.hpp"
 #include <Gosu/Fwd.hpp>
 #include <Gosu/Bitmap.hpp>
+#include <memory>
 #include <vector>
 
-namespace Gosu
+class Gosu::Texture : public std::enable_shared_from_this<Texture>
 {
-    class Texture
-    {
-        BlockAllocator allocator_;
-        GLuint tex_name_;
-        bool retro_;
-
-    public:
-        Texture(unsigned size, bool retro);
-        ~Texture();
-        unsigned size() const;
-        GLuint tex_name() const;
-        bool retro() const;
-        std::unique_ptr<TexChunk>
-            try_alloc(std::shared_ptr<Texture> ptr, const Bitmap& bmp, unsigned padding);
-        void block(unsigned x, unsigned y, unsigned width, unsigned height);
-        void free(unsigned x, unsigned y, unsigned width, unsigned height);
-        Gosu::Bitmap to_bitmap(unsigned x, unsigned y, unsigned width, unsigned height) const;
-    };
-}
+    // BlockAllocator can't be copied or moved, so neither can Texture.
+    BlockAllocator allocator_;
+    GLuint tex_name_;
+    bool retro_;
+    
+public:
+    Texture(unsigned width, unsigned height, bool retro);
+    ~Texture();
+    unsigned width() const;
+    unsigned height() const;
+    GLuint tex_name() const;
+    bool retro() const;
+    std::unique_ptr<TexChunk> try_alloc(const Bitmap& bmp, unsigned padding);
+    void block(unsigned x, unsigned y, unsigned width, unsigned height);
+    void free(unsigned x, unsigned y, unsigned width, unsigned height);
+    Bitmap to_bitmap(unsigned x, unsigned y, unsigned width, unsigned height) const;
+};

data/src/TimingApple.cpp

@@ -16,16 +16,14 @@ void Gosu::sleep(unsigned milliseconds)
 
 unsigned long Gosu::milliseconds()
 {
-    static uint64_t first_tick = 0;
     static mach_timebase_info_data_t info;
-    
-    if (first_tick == 0) {
+    static uint64_t first_tick = [] {
         mach_timebase_info(&info);
-        first_tick = mach_absolute_time();
-    }
-
+        return mach_absolute_time();
+    }();
+    
     uint64_t runtime = mach_absolute_time() - first_tick;
-    return runtime * info.numer / info.denom / 1000000.0;
+    return runtime * info.numer / info.denom / 1000000;
 }
 
 #endif

data/src/TimingUnix.cpp

@@ -21,10 +21,7 @@ unsigned long Gosu::milliseconds()
         start = tp.tv_usec / 1000UL + tp.tv_sec * 1000UL;
     }
 
-    // Truncate to 2^30, C++ users shouldn't mind and Ruby users will
-    // have a happy GC on 32-bit systems.
-    // No, don't ask why this is an unsigned long then :)
-    return (tp.tv_usec / 1000UL + tp.tv_sec * 1000UL - start) & 0x1fffffff;
+    return tp.tv_usec / 1000UL + tp.tv_sec * 1000UL - start;
 }
 
 #endif

data/src/TimingWin.cpp

@@ -12,7 +12,10 @@ void Gosu::sleep(unsigned milliseconds)
 
 unsigned long Gosu::milliseconds()
 {
-    static unsigned long start = (timeBeginPeriod(1), timeGetTime());
+    static unsigned long start = [] {
+        timeBeginPeriod(1);
+        return timeGetTime();
+    }();
     return timeGetTime() - start;
 }