gosu 0.7.10.1

data/GosuImpl/Graphics/BitmapPNG.cpp

@@ -0,0 +1,276 @@
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/IO.hpp>
+#if 0
+#include <boost/thread.hpp>
+#endif
+#include <cassert>
+#include <stdexcept>
+#include <png.h>
+
+namespace Gosu
+{
+    namespace
+    {
+#if 0
+        // Stupid, but everyone would expect loadFromPNG/saveToPNG to be thread-safe.
+        boost::mutex pngMutex;
+#endif
+        
+        Reader* tmpReadStream;
+        Writer* tmpWriteStream;
+
+        void readPNGdata(png_structp png_ptr, png_bytep data, png_size_t length)
+        {
+            tmpReadStream->read(data, length);
+        }
+        void writePNGdata(png_structp png_ptr, png_bytep data, png_size_t length)
+        {
+            tmpWriteStream->write(data, length);
+        }
+        void flushPNGdata(png_structp png_ptr)
+        {
+        }
+    }
+}
+
+Gosu::Reader Gosu::loadFromPNG(Bitmap& out, Reader reader)
+{
+#if 0
+    boost::mutex::scoped_lock lock(pngMutex);
+#endif
+
+    Bitmap newBitmap;
+
+    char header[8];
+    reader.read(header, 8);
+    if (png_sig_cmp(reinterpret_cast<png_byte*>(&header[0]), 0, 8))
+        throw std::runtime_error("Invalid PNG file");
+
+    png_structp pngPtr;
+    // IMPR: Error checking.
+    pngPtr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
+    if (!pngPtr)
+        throw std::runtime_error("Can't create png_structp");
+
+    png_infop infoPtr;
+    infoPtr = png_create_info_struct(pngPtr);
+    if (!infoPtr)
+    {
+        png_destroy_read_struct(&pngPtr, 0, 0);
+        throw std::runtime_error("Can't create png_infop");
+    }
+
+    if (setjmp(png_jmpbuf(pngPtr)))
+    {
+        png_destroy_read_struct(&pngPtr, 0, 0);
+        throw std::runtime_error("libpng error");
+    }
+
+    tmpReadStream = &reader;  // Highly experimental!
+    png_set_read_fn(pngPtr, png_get_io_ptr(pngPtr), readPNGdata);
+
+    png_set_sig_bytes(pngPtr, 8);
+
+    png_read_png(pngPtr, infoPtr, PNG_TRANSFORM_PACKING |
+        PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_SWAP_ALPHA, 0);
+
+    // Get general information about the PNG.
+    png_bytepp rows = png_get_rows(pngPtr, infoPtr);
+    unsigned width = png_get_image_width(pngPtr, infoPtr),
+        height = png_get_image_height(pngPtr, infoPtr),
+        channels = png_get_channels(pngPtr, infoPtr),
+        colorType = png_get_color_type(pngPtr, infoPtr),
+        bitDepth = png_get_bit_depth(pngPtr, infoPtr);
+
+    png_bytep trans;
+    int numTrans = 0;
+    if (png_get_valid(pngPtr, infoPtr, PNG_INFO_tRNS))
+        png_get_tRNS(pngPtr, infoPtr, &trans, &numTrans, NULL);
+    // This function only understands palette images with a bit depth <= 8 and
+    // non-palette images with a bit depth of 8 (the latter is no problem
+    // though, since the transformations given to png_read_png should change
+    // all non-palette images to a bit depth of 8).
+    if ((colorType == PNG_COLOR_TYPE_PALETTE && bitDepth > 8) ||
+        (colorType != PNG_COLOR_TYPE_PALETTE && bitDepth != 8))
+    {
+        png_destroy_read_struct(&pngPtr, &infoPtr, 0);
+        throw std::runtime_error("Unsupported bit depth");
+    }
+
+    // Get palette-related information about the PNG.
+    unsigned palSize;
+    png_colorp palColors;
+    if (colorType == PNG_COLOR_TYPE_PALETTE)
+    {
+        if (!png_get_valid(pngPtr, infoPtr, PNG_INFO_PLTE))
+        {
+            png_destroy_read_struct(&pngPtr, &infoPtr, 0);
+            throw std::runtime_error("PNG palette missing");
+        }
+        png_get_PLTE(pngPtr, infoPtr, &palColors,
+            reinterpret_cast<int*>(&palSize));
+
+        // This should be true after the bit-depth check above.
+        assert(palSize <= 256);
+    }
+
+    try
+    {
+        newBitmap.resize(width, height);
+    }
+    catch (...)
+    {
+        png_destroy_read_struct(&pngPtr, &infoPtr, 0);
+        throw;
+    }
+
+    for (unsigned y = 0; y < height; ++y)
+        for (unsigned x = 0; x < width; ++x)
+        {
+            Color c;
+
+            switch (colorType)
+            {
+                case PNG_COLOR_TYPE_GRAY:
+                {
+                    c.setAlpha(255);
+                    c.setRed  (rows[y][x * channels + 0]);
+                    c.setGreen(rows[y][x * channels + 0]);
+                    c.setBlue (rows[y][x * channels + 0]);
+                    break;
+                }
+                case PNG_COLOR_TYPE_GRAY_ALPHA:
+                {
+                    c.setAlpha(rows[y][x * channels + 0]);
+                    c.setRed  (rows[y][x * channels + 1]);
+                    c.setGreen(rows[y][x * channels + 1]);
+                    c.setBlue (rows[y][x * channels + 1]);
+                    break;
+                }
+                case PNG_COLOR_TYPE_RGB:
+                {
+                    c.setAlpha(255);
+                    c.setRed  (rows[y][x * channels + 0]);
+                    c.setGreen(rows[y][x * channels + 1]);
+                    c.setBlue (rows[y][x * channels + 2]);
+                    break;
+                }
+                case PNG_COLOR_TYPE_RGB_ALPHA:
+                {
+                    c.setAlpha(rows[y][x * channels + 0]);
+                    c.setRed  (rows[y][x * channels + 1]);
+                    c.setGreen(rows[y][x * channels + 2]);
+                    c.setBlue (rows[y][x * channels + 3]);
+                    break;
+                }
+                case PNG_COLOR_TYPE_PALETTE:
+                {
+                    // First get the whole byte in which the palette index is
+                    // stored (but possibly also adjacent indices).
+                    png_byte palIndex = rows[y][x * bitDepth / 8];
+
+                    // Shift the interesting index to the right-most bitDepth
+                    // bits.
+                    palIndex >>= 8 - (x % (8 / bitDepth) + 1) * bitDepth;
+
+                    // Filter out the other indices.
+                    palIndex &= (1 << bitDepth) - 1;
+
+                    if (palIndex >= palSize)
+                    {
+                        png_destroy_read_struct(&pngPtr, &infoPtr, 0);
+                        throw std::runtime_error("Palette index out of range");
+                    }
+                    
+                    int alpha = 255;
+                    for (int i = 0; i < numTrans; ++i)
+                    {
+                        if (trans[i] == palIndex)
+                            alpha = 0;
+                    }
+                    c.setAlpha(alpha);
+                    c.setRed  (palColors[palIndex].red);
+                    c.setGreen(palColors[palIndex].green);
+                    c.setBlue (palColors[palIndex].blue);
+                    break;
+                }
+                default:
+                {
+                    png_destroy_read_struct(&pngPtr, &infoPtr, 0);
+                    throw std::runtime_error("Unsupported PNG color type");
+                }
+            }
+
+            // IMPR: Assumes non-throwing setPixel, which is not yet officially
+            // guaranteed.
+            newBitmap.setPixel(x, y, c);
+        }
+
+    // At last!
+    png_destroy_read_struct(&pngPtr, &infoPtr, 0);
+
+    newBitmap.swap(out);
+
+    return reader; // TODO: Does this point to the right location?
+}
+
+Gosu::Writer Gosu::saveToPNG(const Bitmap& bmp, Writer writer)
+{
+#if 0
+    boost::mutex::scoped_lock lock(pngMutex);
+#endif
+
+    png_structp pngPtr = png_create_write_struct(
+        PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    if (!pngPtr)
+        throw std::runtime_error("Can't create png_structp");
+
+    png_infop infoPtr = png_create_info_struct(pngPtr);
+    if (!infoPtr)
+    {
+        png_destroy_write_struct(&pngPtr, (png_infopp)NULL);
+        throw std::runtime_error("Can't create png_infop");
+    }
+
+    if (setjmp(png_jmpbuf(pngPtr)))        // error handling
+    {
+        png_destroy_write_struct(&pngPtr, &infoPtr);
+        throw std::runtime_error("setjmp() failed");
+    }
+
+    tmpWriteStream = &writer;  // No more experimental.
+    png_set_write_fn(pngPtr, png_get_io_ptr(pngPtr), writePNGdata, flushPNGdata);
+
+    png_set_IHDR(pngPtr, infoPtr, bmp.width(), bmp.height(), 8, PNG_COLOR_TYPE_RGB,
+        PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+    png_write_info(pngPtr, infoPtr);
+
+    png_bytepp rows;
+    rows = new png_bytep[bmp.height()];
+    for(unsigned int y = 0; y < bmp.height(); y++)
+    {
+        rows[y] = new png_byte[bmp.width() * 3];
+        for(unsigned int x = 0; x < bmp.width()*3; x += 3)
+        {
+            rows[y][x] = bmp.getPixel(x/3, y).red();
+            rows[y][x+1] = bmp.getPixel(x/3, y).green();
+            rows[y][x+2] = bmp.getPixel(x/3, y).blue();
+        }
+    }
+
+    png_set_rows(pngPtr, infoPtr, rows);
+    png_write_png(pngPtr, infoPtr, PNG_TRANSFORM_IDENTITY, NULL);
+
+    for(unsigned int i = 0; i < bmp.height(); i++)
+        delete[] rows[i];
+    delete[] rows;
+
+/*    png_write_image(pngPtr, row_pointers); // row_pointers == ?
+    png_write_end(pngPtr, NULL);
+    png_destroy_write_struct(&pngPtr, &infoPtr);*/
+    // TODO: Hey, why is destroy_write_struct commented out?
+
+    return writer; // TODO: Does this point to the right location?
+}
+

data/GosuImpl/Graphics/BitmapUtils.cpp

@@ -0,0 +1,67 @@
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/IO.hpp>
+
+Gosu::Bitmap Gosu::quickLoadBitmap(const std::wstring& filename)
+{
+	Buffer buf;
+	loadFile(buf, filename);
+	Bitmap bmp;
+
+    char formatTester[2];
+    buf.frontReader().read(formatTester, sizeof formatTester);
+    if (formatTester[0] == 'B' && formatTester[1] == 'M')
+    {
+        loadFromBMP(bmp, buf.frontReader());
+        applyColorKey(bmp, Colors::fuchsia);
+    }
+    else
+        loadFromPNG(bmp, buf.frontReader());
+	return bmp;
+}
+
+void Gosu::applyBorderFlags(Bitmap& dest, const Bitmap& source,
+    unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
+    unsigned borderFlags)
+{
+    dest.resize(srcWidth + 2, srcHeight + 2);
+    dest.fill(Colors::none);
+
+    // The borders are made "harder" by duplicating the original bitmap's
+    // borders.
+
+    // Top.
+    if (borderFlags & bfHardTop)
+        dest.insert(source, 1, 0, srcX, srcY, srcWidth, 1);
+    // Bottom.
+    if (borderFlags & bfHardBottom)
+        dest.insert(source, 1, dest.height() - 1,
+            srcX, srcY + srcHeight - 1, srcWidth, 1);
+    // Left.
+    if (borderFlags & bfHardLeft)
+        dest.insert(source, 0, 1, srcX, srcY, 1, srcHeight);
+    // Right.
+    if (borderFlags & bfHardRight)
+        dest.insert(source, dest.width() - 1, 1, 
+            srcX + srcWidth - 1, srcY, 1, srcHeight);
+
+    // Top left.
+    if ((borderFlags & bfHardTop) && (borderFlags & bfHardLeft))
+        dest.setPixel(0, 0,
+            source.getPixel(srcX, srcY));
+    // Top right.
+    if ((borderFlags & bfHardTop) && (borderFlags & bfHardRight))
+        dest.setPixel(dest.width() - 1, 0,
+            source.getPixel(srcX + srcWidth - 1, srcY));
+    // Bottom left.
+    if ((borderFlags & bfHardBottom) && (borderFlags & bfHardLeft))
+        dest.setPixel(0, dest.height() - 1,
+            source.getPixel(srcX, srcY + srcHeight - 1));
+    // Bottom right.
+    if ((borderFlags & bfHardBottom) && (borderFlags & bfHardRight))
+        dest.setPixel(dest.width() - 1, dest.height() - 1,
+            source.getPixel(srcX + srcWidth - 1, srcY + srcHeight - 1));
+
+    // Now put the final image into the prepared borders.
+    dest.insert(source, 1, 1, srcX, srcY, srcWidth, srcHeight);
+}

data/GosuImpl/Graphics/BlockAllocator.cpp

@@ -0,0 +1,127 @@
+#include <GosuImpl/Graphics/BlockAllocator.hpp>
+#include <stdexcept>
+#include <vector>
+
+struct Gosu::BlockAllocator::Impl
+{
+    unsigned width, height;
+
+    typedef std::vector<Block> Blocks;
+    Blocks blocks;
+    unsigned firstX, firstY;
+    unsigned maxW, maxH;
+
+    bool isBlockFree(const Block& block) const
+    {
+        // (The right-th column and the bottom-th row are outside of the block.)
+        unsigned right = block.left + block.width;
+        unsigned bottom = block.top + block.height;
+
+        // Block isn't valid.
+        if (right > width || bottom > height)
+            return false;
+
+        // Test if the block collides with any existing rects.
+        Blocks::const_iterator i, end = blocks.end();
+        for (i = blocks.begin(); i != end; ++i)
+            if (i->left < right && block.left < i->left + i->width &&
+                i->top < bottom && block.top < i->top + i->height)
+            {
+                return false;
+            }
+
+        return true;
+    }
+};
+
+Gosu::BlockAllocator::BlockAllocator(unsigned width, unsigned height)
+: pimpl(new Impl)
+{
+    pimpl->width = width;
+    pimpl->height = height;
+
+    pimpl->firstX = 0;
+    pimpl->firstY = 0;
+
+    pimpl->maxW = width;
+    pimpl->maxH = height;
+}
+
+Gosu::BlockAllocator::~BlockAllocator()
+{
+}
+
+unsigned Gosu::BlockAllocator::width() const
+{
+    return pimpl->width;
+}
+
+unsigned Gosu::BlockAllocator::height() const
+{
+    return pimpl->height;
+}
+
+boost::optional<Gosu::BlockAllocator::Block>
+    Gosu::BlockAllocator::alloc(unsigned aWidth, unsigned aHeight)
+{
+    // The rect wouldn't even fit onto the texture!
+    if (aWidth > width() || aHeight > height())
+        return boost::optional<Block>();
+
+    // It could theoretically fit, but there's no space left.
+    if (aWidth > pimpl->maxW && aHeight > pimpl->maxH)
+        return boost::optional<Block>();
+    
+    // Start to look for a place next to the last returned rect. Chances are
+    // good we'll find a place there.
+    Block b = Block(pimpl->firstX, pimpl->firstY, aWidth, aHeight);
+    if (pimpl->isBlockFree(b))
+    {
+        pimpl->blocks.push_back(b);
+        return b;
+    }
+
+    // Brute force: Look for a free place on this texture.
+    unsigned& x = b.left;
+    unsigned& y = b.top;
+    for (y = 0; y <= height() - aHeight; y += 16)
+        for (x = 0; x <= width() - aWidth; x += 8)
+        {
+            if (!pimpl->isBlockFree(b))
+                continue;
+
+            // Found a nice place!
+
+            // Try to make up for the large for()-stepping.
+            while (y > 0 && pimpl->isBlockFree(Block(x, y - 1, aWidth, aHeight)))
+                --y;
+            while (x > 0 && pimpl->isBlockFree(Block(x - 1, y, aWidth, aHeight)))
+                --x;
+
+            pimpl->blocks.push_back(b);
+            return b;
+        }
+
+    // So there was no space for the bitmap. Remember this for later.
+    pimpl->maxW = aWidth - 1;
+    pimpl->maxH = aHeight - 1;
+    return boost::optional<Block>();
+}
+
+void Gosu::BlockAllocator::free(unsigned left, unsigned top)
+{
+    for (Impl::Blocks::iterator i = pimpl->blocks.begin();
+        i != pimpl->blocks.end(); ++i)
+    {
+        if (i->left == left && i->top == top)
+        {
+            pimpl->blocks.erase(i);
+			// Be optimistic again!
+            pimpl->maxW = pimpl->width - 1;
+            pimpl->maxH = pimpl->height - 1;
+            return;
+        }
+    }
+
+    throw std::logic_error("Tried to free an invalid block");
+}