gosu 0.10.9.pre1 → 0.11.0

data/src/TextWin.cpp

@@ -0,0 +1,194 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_WIN)
+
+#define _WIN32_WINNT 0x0500 
+#include <windows.h>
+
+#include "WinUtility.hpp"
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Text.hpp>
+#include <Gosu/Utility.hpp>
+#include <cstdlib>
+#include <cwchar>
+#include <algorithm>
+#include <map>
+#include <set>
+#include <stdexcept>
+
+std::string Gosu::default_font_name()
+{
+    return "Arial";
+}
+
+namespace Gosu
+{
+    std::string get_name_from_ttf_file(const std::wstring& filename);
+
+    namespace
+    {
+        class WinBitmap
+        {
+            WinBitmap(const WinBitmap&);
+            WinBitmap& operator=(const WinBitmap&);
+            
+            HDC dc;
+            HBITMAP bitmap;
+            char* pixels;
+
+        public:
+            WinBitmap(unsigned width, unsigned height)
+            {
+                dc = winapi_check(CreateCompatibleDC(0), "creating a device context");
+
+                BITMAPCOREHEADER core_header;
+                core_header.bcSize = sizeof core_header;
+                core_header.bcWidth = width;
+                core_header.bcHeight = height;
+                core_header.bcPlanes = 1;
+                core_header.bcBitCount = 24;
+
+                bitmap = CreateDIBSection(dc, reinterpret_cast<BITMAPINFO*>(&core_header),
+                                          DIB_RGB_COLORS, reinterpret_cast<VOID**>(&pixels), 0, 0);
+                if (bitmap == 0) {
+                    DeleteDC(dc);
+                    throw_last_winapi_error("creating a bitmap");
+                }
+
+                SelectObject(dc, bitmap);
+
+                HBRUSH brush = CreateSolidBrush(0x000000);
+                RECT rc = { 0, 0, width, height };
+                FillRect(dc, &rc, brush);
+                DeleteObject(brush);
+            }
+
+            ~WinBitmap()
+            {
+                DeleteObject(bitmap);
+                SelectObject(dc, GetStockObject(SYSTEM_FONT));
+                DeleteDC(dc);
+            }
+
+            HDC context() const
+            {
+                return dc;
+            }
+
+            HBITMAP handle() const
+            {
+                return bitmap;
+            }
+
+            void select_font(std::string font_name, unsigned font_height, unsigned font_flags) const
+            {
+                // TODO for ASYNC support:
+                // Use a lock on both maps.
+
+                // Note:
+                // The caching of opened fonts didn't really show improved text rendering
+                // performance on my test system.
+                // In case of trouble, it can be taken out without worrying too much.
+
+                static std::map<std::string, std::string> custom_fonts;
+                
+                if (font_name.find("/") != font_name.npos) {
+                    if (custom_fonts.count(font_name) == 0) {
+                        std::wstring wfont_name = utf8_to_wstring(font_name);
+                        AddFontResourceExW(wfont_name.c_str(), FR_PRIVATE, 0);
+                        font_name = custom_fonts[font_name] = get_name_from_ttf_file(wfont_name);
+                    }
+                    else {
+                        font_name = custom_fonts[font_name];
+                    }
+                }
+                
+                static std::map<std::pair<std::string, unsigned>, HFONT> loaded_fonts;
+                
+                HFONT font;
+                std::pair<std::string, unsigned> key =
+                    std::make_pair(font_name, font_height | font_flags << 16);
+                
+                if (loaded_fonts.count(key) == 0) {
+                    LOGFONT logfont = {
+                        font_height, 0, 0, 0,
+                        font_flags & FF_BOLD ? FW_BOLD : FW_NORMAL,
+                        font_flags & FF_ITALIC ? TRUE : FALSE,
+                        font_flags & FF_UNDERLINE ? TRUE : FALSE, FALSE, DEFAULT_CHARSET,
+                        OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY,
+                        DEFAULT_PITCH | FF_DONTCARE
+                    };
+                    
+                    std::wstring wfont_name = utf8_to_wstring(font_name);
+                    // Don't rely on wcsncpy being in std::...
+                    using namespace std;
+                    wcsncpy(logfont.lfFaceName, wfont_name.c_str(), LF_FACESIZE);
+                    logfont.lfFaceName[LF_FACESIZE - 1] = 0;
+                    
+                    font = loaded_fonts[key] = winapi_check(CreateFontIndirect(&logfont),
+                                                            "CreateFontIndirect for " + font_name);
+                }
+                else {
+                    font = loaded_fonts[key];
+                }
+
+                SelectObject(dc, font);
+            }
+        };
+    }
+};
+
+unsigned Gosu::text_width(const std::string& text, const std::string& font_name,
+    unsigned font_height, unsigned font_flags)
+{
+    if (text.find_first_of("\r\n") != text.npos) {
+        throw std::invalid_argument("the argument to text_width cannot contain line breaks");
+    }
+    
+    WinBitmap helper(1, 1);
+    helper.select_font(font_name, font_height, font_flags);
+    
+    std::wstring wtext = utf8_to_wstring(text);
+    SIZE size;
+    winapi_check(GetTextExtentPoint32W(helper.context(), wtext.c_str(), text.length(), &size),
+        "calculating the width of a text");
+    
+    return size.cx;
+}
+
+void Gosu::draw_text(Bitmap& bitmap, const std::string& text, int x, int y, Color c,
+    const std::string& font_name, unsigned font_height, unsigned font_flags)
+{
+    if (text.find_first_of("\r\n") != text.npos) {
+        throw std::invalid_argument("the argument to draw_text cannot contain line breaks");
+    }
+    
+    unsigned width = text_width(text, font_name, font_height, font_flags);
+
+    WinBitmap helper(width, font_height);
+    helper.select_font(font_name, font_height, font_flags);
+
+    winapi_check(SetTextColor(helper.context(), 0xffffff) != CLR_INVALID,
+        "setting the text color");
+
+    winapi_check(SetBkMode(helper.context(), TRANSPARENT),
+        "setting a bitmap's background mode to TRANSPARENT");
+
+    std::wstring wtext = utf8_to_wstring(text);
+    ExtTextOutW(helper.context(), 0, 0, 0, 0, wtext.c_str(), text.length(), 0);
+    
+    for (unsigned rel_y = 0; rel_y < font_height; ++rel_y)
+        for (unsigned rel_x = 0; rel_x < width; ++rel_x) {
+            Color pixel = c;
+            Color::Channel src_alpha = GetPixel(helper.context(), rel_x, rel_y) & 0xff;
+            
+            if (src_alpha == 0) continue;
+            
+            pixel = multiply(c, Color(src_alpha, 255, 255, 255));
+            if (pixel != 0 && x + rel_x >= 0 && x + rel_x < bitmap.width() &&
+                    y + rel_y >= 0 && y + rel_y < bitmap.height()) {
+                bitmap.set_pixel(x + rel_x, y + rel_y, pixel);
+            }
+        }
+}
+
+#endif

data/src/{Graphics/Texture.cpp → Texture.cpp}

@@ -1,42 +1,41 @@
-#include <Gosu/Graphics.hpp>
 #include "Texture.hpp"
 #include "TexChunk.hpp"
 #include <Gosu/Bitmap.hpp>
+#include <Gosu/Graphics.hpp>
 #include <Gosu/Platform.hpp>
 #include <stdexcept>
 
 namespace Gosu
 {
-    bool undocumentedRetrofication = false;
+    bool undocumented_retrofication = false;
 }
 
 Gosu::Texture::Texture(unsigned size, bool retro)
 : allocator_(size, size), retro_(retro)
 {
-    ensureCurrentContext();
+    ensure_current_context();
     
     // Create texture name.
-    glGenTextures(1, &texName_);
-    if (texName_ == static_cast<GLuint>(-1))
+    glGenTextures(1, &tex_name_);
+    if (tex_name_ == static_cast<GLuint>(-1)) {
         throw std::runtime_error("Couldn't create OpenGL texture");
-   
+    }
+
     // Create empty texture.
-    glBindTexture(GL_TEXTURE_2D, texName_);
+    glBindTexture(GL_TEXTURE_2D, tex_name_);
 #ifdef GOSU_IS_OPENGLES
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, allocator_.width(), allocator_.height(), 0,
-                 GL_RGBA, GL_UNSIGNED_BYTE, 0);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, allocator_.width(), allocator_.height(), 0, GL_RGBA,
+        GL_UNSIGNED_BYTE, nullptr);
 #else
-    glTexImage2D(GL_TEXTURE_2D, 0, 4, allocator_.width(), allocator_.height(), 0,
-                 GL_RGBA, GL_UNSIGNED_BYTE, 0);
+    glTexImage2D(GL_TEXTURE_2D, 0, 4, allocator_.width(), allocator_.height(), 0, GL_RGBA,
+        GL_UNSIGNED_BYTE, nullptr);
 #endif
     
-    if (retro || undocumentedRetrofication)
-    {
+    if (retro || undocumented_retrofication) {
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     }
-    else
-    {
+    else {
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     }
@@ -52,9 +51,9 @@ Gosu::Texture::Texture(unsigned size, bool retro)
 
 Gosu::Texture::~Texture()
 {
-    ensureCurrentContext();
+    ensure_current_context();
     
-    glDeleteTextures(1, &texName_);
+    glDeleteTextures(1, &tex_name_);
 }
 
 unsigned Gosu::Texture::size() const
@@ -62,9 +61,9 @@ unsigned Gosu::Texture::size() const
     return allocator_.width(); // == height
 }
 
-GLuint Gosu::Texture::texName() const
+GLuint Gosu::Texture::tex_name() const
 {
-    return texName_;
+    return tex_name_;
 }
 
 bool Gosu::Texture::retro() const
@@ -72,25 +71,23 @@ bool Gosu::Texture::retro() const
     return retro_;
 }
 
-GOSU_UNIQUE_PTR<Gosu::TexChunk>
-    Gosu::Texture::tryAlloc(std::tr1::shared_ptr<Texture> ptr, const Bitmap& bmp, unsigned padding)
+std::unique_ptr<Gosu::TexChunk>
+    Gosu::Texture::try_alloc(std::shared_ptr<Texture> ptr, const Bitmap& bmp, unsigned padding)
 {
-    GOSU_UNIQUE_PTR<Gosu::TexChunk> result;
-    
     BlockAllocator::Block block;
-    if (!allocator_.alloc(bmp.width(), bmp.height(), block))
-        return result;
     
-    result.reset(new TexChunk(ptr, block.left + padding, block.top + padding,
-                              block.width - 2 * padding, block.height - 2 * padding, padding));
+    if (!allocator_.alloc(bmp.width(), bmp.height(), block)) return nullptr;
+    
+    std::unique_ptr<Gosu::TexChunk> result(new TexChunk(ptr, block.left + padding,
+        block.top + padding, block.width - 2 * padding, block.height - 2 * padding, padding));
     
-    ensureCurrentContext();
+    ensure_current_context();
     
-    glBindTexture(GL_TEXTURE_2D, texName_);
+    glBindTexture(GL_TEXTURE_2D, tex_name_);
     glTexSubImage2D(GL_TEXTURE_2D, 0, block.left, block.top, block.width, block.height,
-                 Color::GL_FORMAT, GL_UNSIGNED_BYTE, bmp.data());
+        Color::GL_FORMAT, GL_UNSIGNED_BYTE, bmp.data());
 
-    return GOSU_MOVE_UNIQUE_PTR(result);
+    return std::move(result);
 }
 
 void Gosu::Texture::block(unsigned x, unsigned y, unsigned width, unsigned height)
@@ -103,18 +100,18 @@ void Gosu::Texture::free(unsigned x, unsigned y, unsigned width, unsigned height
     allocator_.free(x, y, width, height);
 }
 
-Gosu::Bitmap Gosu::Texture::toBitmap(unsigned x, unsigned y, unsigned width, unsigned height) const
+Gosu::Bitmap Gosu::Texture::to_bitmap(unsigned x, unsigned y, unsigned width, unsigned height) const
 {
 #ifdef GOSU_IS_OPENGLES
-    throw std::logic_error("Texture::toBitmap not supported on iOS");
+    throw std::logic_error("Texture::to_bitmap not supported on iOS");
 #else
-    ensureCurrentContext();
+    ensure_current_context();
     
-    Gosu::Bitmap fullTexture(size(), size());
-    glBindTexture(GL_TEXTURE_2D, texName());
-    glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, fullTexture.data());
+    Gosu::Bitmap full_texture(size(), size());
+    glBindTexture(GL_TEXTURE_2D, tex_name());
+    glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, full_texture.data());
     Gosu::Bitmap bitmap(width, height);
-    bitmap.insert(fullTexture, -int(x), -int(y));
+    bitmap.insert(full_texture, -int(x), -int(y));
     
     return bitmap;
 #endif

data/src/{Graphics/Texture.hpp → Texture.hpp}

@@ -1,12 +1,10 @@
-#ifndef GOSU_SRC_GRAPHICS_TEXTURE_HPP
-#define GOSU_SRC_GRAPHICS_TEXTURE_HPP
+#pragma once
 
+#include "BlockAllocator.hpp"
+#include "GraphicsImpl.hpp"
+#include "TexChunk.hpp"
 #include <Gosu/Fwd.hpp>
 #include <Gosu/Bitmap.hpp>
-#include <Gosu/TR1.hpp>
-#include "Common.hpp"
-#include "TexChunk.hpp"
-#include "BlockAllocator.hpp"
 #include <vector>
 
 namespace Gosu
@@ -14,21 +12,19 @@ namespace Gosu
     class Texture
     {
         BlockAllocator allocator_;
-        GLuint texName_;
+        GLuint tex_name_;
         bool retro_;
 
     public:
         Texture(unsigned size, bool retro);
         ~Texture();
         unsigned size() const;
-        GLuint texName() const;
+        GLuint tex_name() const;
         bool retro() const;
-        GOSU_UNIQUE_PTR<TexChunk>
-            tryAlloc(std::tr1::shared_ptr<Texture> ptr, const Bitmap& bmp, unsigned padding);
+        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 toBitmap(unsigned x, unsigned y, unsigned width, unsigned height) const;
+        Gosu::Bitmap to_bitmap(unsigned x, unsigned y, unsigned width, unsigned height) const;
     };
 }
-
-#endif

data/src/TimingApple.cpp

@@ -1,9 +1,12 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_MAC)
+
 #include <Gosu/Timing.hpp>
 #include <unistd.h>
 
 void Gosu::sleep(unsigned milliseconds)
 {
-	usleep(milliseconds * 1000);
+    usleep(milliseconds * 1000);
 }
 
 // Thanks to this blog for the unconvoluted code example:
@@ -13,15 +16,16 @@ void Gosu::sleep(unsigned milliseconds)
 
 unsigned long Gosu::milliseconds()
 {
-    static uint64_t firstTick = 0;
+    static uint64_t first_tick = 0;
     static mach_timebase_info_data_t info;
     
-    if (firstTick == 0)
-    {
+    if (first_tick == 0) {
         mach_timebase_info(&info);
-        firstTick = mach_absolute_time();
+        first_tick = mach_absolute_time();
     }
 
-    uint64_t runtime = mach_absolute_time() - firstTick;
-	return runtime * info.numer / info.denom / 1000000.0;
+    uint64_t runtime = mach_absolute_time() - first_tick;
+    return runtime * info.numer / info.denom / 1000000.0;
 }
+
+#endif

data/src/TimingUnix.cpp

@@ -1,24 +1,30 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_X)
+
 #include <Gosu/Timing.hpp>
-#include <unistd.h>
 #include <sys/time.h>
+#include <unistd.h>
 
 void Gosu::sleep(unsigned milliseconds)
 {
-	usleep(milliseconds * 1000);
+    usleep(milliseconds * 1000);
 }
 
 unsigned long Gosu::milliseconds()
 {
-		static unsigned long start = 0;
+    static unsigned long start = 0;
 
     timeval tp;
-    gettimeofday(&tp, NULL);
+    gettimeofday(&tp, nullptr);
+
+    if (!start) {
+        start = tp.tv_usec / 1000UL + tp.tv_sec * 1000UL;
+    }
 
-		if (!start)
-			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;
 }
+
+#endif