gosu 0.7.10.1

data/GosuImpl/Graphics/TextPangoFT.cpp

@@ -0,0 +1,186 @@
+#include <Gosu/Text.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Utility.hpp>
+
+#include <pango/pango.h>
+#include <pango/pangoft2.h>
+
+#include <glib.h>
+
+#include <string>
+
+std::wstring Gosu::defaultFontName()
+{
+    return L"sans";
+}
+
+namespace Gosu
+{
+    class pango
+    {
+        int width, height;
+
+        PangoContext* context;
+        PangoLayout* layout;
+        /*static*/ PangoFontDescription *font_description;
+        PangoAttribute* attr;
+        PangoAttrList* attrList;
+
+    public:
+        pango();
+        ~pango();
+        unsigned textWidth(const std::wstring& text,
+            const std::wstring& fontFace, unsigned fontHeight,
+            unsigned fontFlags);
+        void drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
+            Color c, const std::wstring& fontFace, unsigned fontHeight,
+            unsigned fontFlags);
+    };
+}
+
+Gosu::pango::pango()
+{
+    font_description = NULL;
+    attr = NULL;
+    attrList = NULL;
+}
+
+Gosu::pango::~pango()
+{
+    g_object_unref(context);
+    g_object_unref(layout);
+    
+    if(font_description)
+        pango_font_description_free(font_description);
+    if(attr)
+        pango_attribute_destroy(attr);
+}
+
+unsigned Gosu::pango::textWidth(const std::wstring& text,
+    const std::wstring& fontFace, unsigned fontHeight,
+    unsigned fontFlags)
+{
+    g_type_init();
+
+    int dpi_x = 100, dpi_y = 100;
+
+    context = pango_ft2_get_context(dpi_x, dpi_y);
+
+    pango_context_set_language(context, pango_language_from_string ("en_US"));
+    PangoDirection init_dir = PANGO_DIRECTION_LTR;
+    pango_context_set_base_dir(context, init_dir);
+
+//    static PangoFontDescription *font_description;
+    font_description = pango_font_description_new();
+
+    pango_font_description_set_family(font_description,
+        g_strdup(narrow(fontFace).c_str()));
+    pango_font_description_set_style(font_description,
+        (fontFlags & ffItalic) ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);
+    pango_font_description_set_variant(font_description, PANGO_VARIANT_NORMAL);
+    pango_font_description_set_weight(font_description,
+        (fontFlags & ffBold) ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL);
+    pango_font_description_set_stretch(font_description, PANGO_STRETCH_NORMAL);
+    int init_scale = int(fontHeight/2.0 + 0.5);
+    pango_font_description_set_size(font_description, init_scale * PANGO_SCALE);
+
+    pango_context_set_font_description(context, font_description);
+
+
+    layout = pango_layout_new(context);
+
+
+    if(fontFlags & ffUnderline)
+    {
+//        PangoAttribute *attr;
+        attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
+        attr->start_index = 0;
+        attr->end_index = text.length();
+//        PangoAttrList* attrList;
+        attrList = pango_attr_list_new();
+        pango_attr_list_insert(attrList, attr);
+        pango_layout_set_attributes(layout, attrList);
+        pango_attr_list_unref(attrList);
+    }
+
+
+    // IMPR: Catch errors? (Last NULL-Pointer)
+    gchar* utf8Str = g_ucs4_to_utf8((gunichar*)text.c_str(), text.length(), NULL, NULL, NULL);
+    pango_layout_set_text(layout, utf8Str, -1);
+    g_free(utf8Str);
+
+    PangoDirection base_dir = pango_context_get_base_dir(context);
+    pango_layout_set_alignment(layout,
+        base_dir == PANGO_DIRECTION_LTR ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT);
+
+    pango_layout_set_width(layout, -1);
+
+    PangoRectangle logical_rect;
+
+    pango_layout_get_pixel_extents(layout, NULL, &logical_rect);
+    height = logical_rect.height;
+    width = logical_rect.width;
+
+    return width;
+}
+
+void Gosu::pango::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
+    Color c, const std::wstring& fontFace, unsigned fontHeight,
+    unsigned fontFlags)
+{
+    textWidth(text, fontFace, fontHeight, fontFlags);
+
+    FT_Bitmap ft_bitmap;
+
+    guchar* buf = new guchar[width * height];
+    std::fill(buf, buf + width * height, 0x00);
+
+    ft_bitmap.rows = height;
+    ft_bitmap.width = width;
+    ft_bitmap.pitch = ft_bitmap.width;
+    ft_bitmap.buffer = buf;
+    ft_bitmap.num_grays = 256;
+    ft_bitmap.pixel_mode = ft_pixel_mode_grays;
+
+    int x_start = 0;
+    pango_ft2_render_layout(&ft_bitmap, layout, x_start, 0);
+
+
+    int min_height = height;
+    if((unsigned)height > fontHeight) min_height = fontHeight;
+
+    for(int y2 = 0; y2 < min_height; y2++)
+    {
+        if (y + y2 < 0 || y + y2 >= bitmap.height())
+            break;
+        
+        for(int x2 = 0; x2 < width; x2++)
+        {
+            if (x + x2 < 0 || x + x2 >= bitmap.width())
+                break;
+            unsigned val = ft_bitmap.buffer[y2*width+x2];
+            Color color = c;
+            color.setAlpha(val);
+            bitmap.setPixel(x2 + x, y2 + y, color);
+        }
+    }
+
+    delete[] buf;
+}
+
+
+unsigned Gosu::textWidth(const std::wstring& text,
+    const std::wstring& fontFace, unsigned fontHeight,
+    unsigned fontFlags)
+{
+    pango helper;
+    return helper.textWidth(text, fontFace, fontHeight, fontFlags);
+}
+
+void Gosu::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
+    Color c, const std::wstring& fontFace, unsigned fontHeight,
+    unsigned fontFlags)
+{
+    pango helper;
+    helper.drawText(bitmap, text, x, y, c, fontFace, fontHeight, fontFlags);
+}

data/GosuImpl/Graphics/TextWin.cpp

@@ -0,0 +1,172 @@
+#define _WIN32_WINNT 0x0500 
+#include <windows.h>
+
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Text.hpp>
+#include <Gosu/Utility.hpp>
+#include <Gosu/WinUtility.hpp>
+#include <boost/utility.hpp>
+#include <cstdlib>
+#include <cwchar>
+#include <algorithm>
+#include <stdexcept>
+#include <map>
+#include <set>
+
+std::wstring Gosu::defaultFontName()
+{
+    return L"Arial";
+}
+
+// IMPR: throwLastError/check is used a lot here, Win9x doesn't provide GDI
+// error codes though. Wait until 9x is dead or fix this!
+
+namespace Gosu
+{
+    std::wstring getNameFromTTFFile(const std::wstring& filename);
+
+    namespace
+    {
+        class WinBitmap : boost::noncopyable
+        {
+            HDC dc;
+            HBITMAP bitmap;
+            char* pixels;
+
+        public:
+            WinBitmap(unsigned width, unsigned height)
+            {
+                dc = Win::check(::CreateCompatibleDC(0),
+                    "creating a device context");
+
+                BITMAPCOREHEADER coreHeader;
+                coreHeader.bcSize     = sizeof coreHeader;
+                coreHeader.bcWidth    = width;
+                coreHeader.bcHeight   = height;
+                coreHeader.bcPlanes   = 1;
+                coreHeader.bcBitCount = 24;
+
+                bitmap = ::CreateDIBSection(dc,
+                    reinterpret_cast<BITMAPINFO*>(&coreHeader), DIB_RGB_COLORS,
+                    reinterpret_cast<VOID**>(&pixels), 0, 0);
+                if (bitmap == 0)
+                {
+                    ::DeleteDC(dc);
+                    Win::throwLastError("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);
+                ::DeleteObject(::SelectObject(dc, ::GetStockObject(SYSTEM_FONT)));
+                ::DeleteDC(dc);
+            }
+
+            HDC context() const
+            {
+                return dc;
+            }
+
+            HBITMAP handle() const
+            {
+                return bitmap;
+            }
+
+            /*char* data() const
+            {
+                return pixels;
+            }*/
+
+            void selectFont(std::wstring fontName, unsigned fontHeight,
+                unsigned fontFlags) const
+            {
+                static std::map<std::wstring, std::wstring> customFonts;
+
+                if (fontName.find(L"/") != std::wstring::npos)
+                {
+                    if (customFonts.count(fontName) == 0)
+                    {
+                        AddFontResourceEx(fontName.c_str(), FR_PRIVATE, 0);
+                        fontName = customFonts[fontName] = getNameFromTTFFile(fontName);
+                    }
+                    else
+                        fontName = customFonts[fontName];
+                }
+
+                // IMPR: Maybe remember the last font we had and don't
+                // recreate it every time?
+
+                LOGFONT logfont = { fontHeight, 0, 0, 0,
+                    fontFlags & ffBold ? FW_BOLD : FW_NORMAL,
+                    fontFlags & ffItalic ? TRUE : FALSE,
+                    fontFlags & ffUnderline ? TRUE : FALSE,
+                    FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
+                    CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY,
+                    DEFAULT_PITCH | FF_DONTCARE };
+
+                // IMPR: This truncates. Is this reasonable? Should we rather
+                // throw something?
+                /*std::*/wcsncpy(logfont.lfFaceName, fontName.c_str(), LF_FACESIZE);
+                logfont.lfFaceName[LF_FACESIZE - 1] = 0;
+
+                HFONT newFont = Win::check(::CreateFontIndirect(&logfont),
+                    "creating font object for " + narrow(fontName));
+
+                HFONT oldFont = reinterpret_cast<HFONT>(::SelectObject(dc, newFont));
+                Win::check(oldFont, "selecting the font object for " + narrow(fontName));
+                ::DeleteObject(oldFont);
+            }
+        };
+    }
+};
+
+unsigned Gosu::textWidth(const std::wstring& text,
+    const std::wstring& fontName, unsigned fontHeight, unsigned fontFlags)
+{
+    WinBitmap helper(1, 1);
+    helper.selectFont(fontName, fontHeight, fontFlags);
+    
+    SIZE size;
+    if (!::GetTextExtentPoint32(helper.context(), text.c_str(), text.length(), &size))
+        Win::throwLastError("calculating the width of a text");
+    
+    return size.cx;
+}
+
+void Gosu::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
+    Color c, const std::wstring& fontName, unsigned fontHeight,
+    unsigned fontFlags)
+{
+    unsigned width = textWidth(text, fontName, fontHeight, fontFlags);
+
+    WinBitmap helper(width, fontHeight);
+    helper.selectFont(fontName, fontHeight, fontFlags);
+
+    if (::SetTextColor(helper.context(), 0xffffff) == CLR_INVALID)
+        Win::throwLastError("setting the text color");
+
+    Win::check(::SetBkMode(helper.context(), TRANSPARENT),
+        "setting a bitmap's background mode to TRANSPARENT");
+
+    ::ExtTextOut(helper.context(), 0, 0, 0, 0, text.c_str(), text.length(), 0);
+
+    for (unsigned relY = 0; relY < fontHeight; ++relY)
+        for (unsigned relX = 0; relX < width; ++relX)
+        {
+            Color pixel = c;
+            pixel.setAlpha(GetPixel(helper.context(), relX, relY) & 0xff);
+            // IMPR: Make better use of c.alpha()?
+            // Maybe even add an AlphaMode parameter?
+            if (pixel != 0 && x + relX >= 0 && x + relX < bitmap.width() &&
+                y + relY >= 0 && y + relY < bitmap.height())
+                bitmap.setPixel(x + relX, y + relY, pixel);
+        }
+}

data/GosuImpl/Graphics/Texture.cpp

@@ -0,0 +1,104 @@
+#include <GosuImpl/Graphics/Texture.hpp>
+#include <GosuImpl/Graphics/TexChunk.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Platform.hpp>
+#include <stdexcept>
+
+// TODO: Not threadsafe.
+unsigned Gosu::Texture::maxTextureSize()
+{
+    const static unsigned MIN_SIZE = 256, MAX_SIZE = 1024;
+
+    static unsigned size = 0;
+    if (size == 0)
+    {
+        size = MIN_SIZE / 2;
+        GLint width = 1;
+        do
+        {
+            size *= 2;
+            glTexImage2D(GL_PROXY_TEXTURE_2D, 0, 4, size * 2, size * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+            glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width); 
+        } while (width != 0 && size < MAX_SIZE);
+    }
+        
+    return size;
+}
+
+Gosu::Texture::Texture(unsigned size)
+: allocator(size, size), num(0)
+{
+    // Create texture name.
+    glGenTextures(1, &name);
+    if (name == static_cast<GLuint>(-1))
+        throw std::runtime_error("Couldn't create OpenGL texture");
+   
+    // Create empty texture.
+    glBindTexture(GL_TEXTURE_2D, name);
+    glTexImage2D(GL_TEXTURE_2D, 0, 4, allocator.width(), allocator.height(), 0,
+                 GL_RGBA, GL_UNSIGNED_BYTE, 0);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+}
+
+Gosu::Texture::~Texture()
+{
+    glDeleteTextures(1, &name);
+}
+
+unsigned Gosu::Texture::size() const
+{
+    return allocator.width(); // == height
+}
+
+GLuint Gosu::Texture::texName() const
+{
+    return name;
+}
+
+std::auto_ptr<Gosu::TexChunk>
+    Gosu::Texture::tryAlloc(Graphics& graphics,
+        DrawOpQueue& queue, boost::shared_ptr<Texture> ptr,
+        const Bitmap& bmp, unsigned srcX,
+        unsigned srcY, unsigned srcWidth,
+        unsigned srcHeight, unsigned padding)
+{
+    std::auto_ptr<Gosu::TexChunk> result;
+    
+    boost::optional<BlockAllocator::Block> block = allocator.alloc(srcWidth, srcHeight);
+    if (!block)
+        return result;
+    
+    result.reset(new TexChunk(graphics, queue, ptr, block->left + padding, block->top + padding,
+                              block->width - 2 * padding, block->height - 2 * padding, padding));
+                              
+    #ifdef __BIG_ENDIAN__
+    std::vector<unsigned> pixelData(srcWidth * srcHeight);
+    for (unsigned y = 0; y < srcHeight; ++y)
+        for (unsigned x = 0; x < srcWidth; ++x)
+        {
+            boost::uint32_t pixVal = (bmp.getPixel(x, y).argb() & 0x00ffffff) << 8 | bmp.getPixel(x, y).alpha();
+            pixVal = bigToNative(pixVal);
+            pixelData[y * srcWidth + x] = pixVal;
+        }
+    const unsigned* texData = &pixelData[0];
+    unsigned format = GL_RGBA;
+    #else
+    #ifndef GL_BGRA
+    #define GL_BGRA 0x80E1
+    #endif
+    const unsigned* texData = bmp.glCompatibleData();
+    unsigned format = GL_BGRA;
+    #endif
+    
+    glBindTexture(GL_TEXTURE_2D, name);
+    glTexSubImage2D(GL_TEXTURE_2D, 0, block->left, block->top, block->width, block->height,
+                 format, GL_UNSIGNED_BYTE, texData);
+    num += 1;
+    return result;
+}
+
+void Gosu::Texture::free(unsigned x, unsigned y)
+{
+    allocator.free(x, y);
+    num -= 1;
+}