gosu 0.7.10.1

data/GosuImpl/FileWin.cpp

@@ -0,0 +1,83 @@
+#include <Gosu/IO.hpp>
+#include <Gosu/Utility.hpp>
+#include <Gosu/WinUtility.hpp>
+#include <windows.h>
+
+// IMPR: Error checking
+
+struct Gosu::File::Impl
+{
+    HANDLE handle;
+
+    Impl()
+    : handle(INVALID_HANDLE_VALUE)
+    {
+    }
+
+    ~Impl()
+    {
+        if (handle != INVALID_HANDLE_VALUE)
+            ::CloseHandle(handle);
+    }
+};
+
+Gosu::File::File(const std::wstring& filename, FileMode mode)
+: pimpl(new Impl)
+{
+    DWORD access;
+    switch (mode)
+    {
+    case fmRead:
+        access = GENERIC_READ;
+        break;
+    case fmReplace:
+        access = GENERIC_WRITE;
+        break;
+    case fmAlter:
+        access = GENERIC_READ | GENERIC_WRITE;
+        break;
+    }
+    DWORD shareMode = FILE_SHARE_READ;
+    DWORD creationDisp = (mode == fmRead) ? OPEN_EXISTING : OPEN_ALWAYS;
+
+    pimpl->handle = ::CreateFile(filename.c_str(), access, shareMode, 0,
+        creationDisp, FILE_ATTRIBUTE_NORMAL, 0);
+    if (pimpl->handle == INVALID_HANDLE_VALUE)
+        Win::throwLastError("opening " + Gosu::narrow(filename));
+    if (mode == fmReplace)
+        resize(0);
+}
+
+Gosu::File::~File()
+{
+}
+
+std::size_t Gosu::File::size() const
+{
+    return ::GetFileSize(pimpl->handle, 0);
+}
+
+void Gosu::File::resize(std::size_t newSize)
+{
+    if (::SetFilePointer(pimpl->handle, newSize, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
+        Win::throwLastError("setting the file pointer");
+    Win::check(::SetEndOfFile(pimpl->handle), "resizing a file");
+}
+
+void Gosu::File::read(std::size_t offset, std::size_t length,
+    void* destBuffer) const
+{
+    if (::SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
+        Win::throwLastError("setting the file pointer");
+    DWORD dummy;
+    Win::check(::ReadFile(pimpl->handle, destBuffer, length, &dummy, 0));
+}
+
+void Gosu::File::write(std::size_t offset, std::size_t length,
+    const void* sourceBuffer)
+{
+    if (::SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
+        Win::throwLastError("setting the file pointer");
+    DWORD dummy;
+    Win::check(::WriteFile(pimpl->handle, sourceBuffer, length, &dummy, 0));
+}

data/GosuImpl/Graphics/Bitmap.cpp

@@ -0,0 +1,116 @@
+#include <Gosu/Bitmap.hpp>
+#include <cassert>
+#include <algorithm>
+#include <vector>
+
+Gosu::Bitmap::Bitmap()
+: w(0), h(0)
+{
+}
+
+/*unsigned Gosu::Bitmap::width() const
+{
+    return w;
+}
+
+unsigned Gosu::Bitmap::height() const
+{
+    return h;
+}*/
+
+void Gosu::Bitmap::swap(Bitmap& other)
+{
+    std::swap(pixels, other.pixels);
+    std::swap(w, other.w);
+    std::swap(h, other.h);
+}
+
+void Gosu::Bitmap::resize(unsigned width, unsigned height, Color c)
+{
+    Bitmap temp;
+    temp.pixels.resize(width * height, c);
+    temp.w = width;
+    temp.h = height;
+    temp.insert(*this, 0, 0);
+    swap(temp);
+}
+
+void Gosu::Bitmap::fill(Color c)
+{
+    std::fill(pixels.begin(), pixels.end(), c);
+}
+
+void Gosu::Bitmap::replace(Color what, Color with)
+{
+    std::replace(pixels.begin(), pixels.end(), what, with);
+}
+
+/*Gosu::Color Gosu::Bitmap::getPixel(unsigned x, unsigned y) const
+{
+    assert(x <= w);
+    assert(y <= h);
+    assert(w*h > 0);
+    return pixels[y * w + x];
+}
+
+void Gosu::Bitmap::setPixel(unsigned x, unsigned y, Color c)
+{
+    assert(x <= w);
+    assert(y <= h);
+    assert(w*h > 0);
+    pixels[y * w + x] = c;
+}*/
+
+void Gosu::Bitmap::insert(const Bitmap& source, int x, int y)
+{
+    insert(source, x, y, 0, 0, source.width(), source.height());
+}
+
+void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, unsigned srcX,
+    unsigned srcY, unsigned srcWidth, unsigned srcHeight)
+{
+    if (x < 0)
+    {
+        unsigned clipLeft = -x;
+
+        if (clipLeft >= srcWidth)
+            return;
+
+        srcX += clipLeft;
+        srcWidth -= clipLeft;
+        x = 0;
+    }
+
+    if (y < 0)
+    {
+        unsigned clipTop = -y;
+
+        if (clipTop >= srcHeight)
+            return;
+
+        srcY += clipTop;
+        srcHeight -= clipTop;
+        y = 0;
+    }
+
+    if (x + srcWidth > w)
+    {
+        if (static_cast<unsigned>(x) >= w)
+            return;
+
+        srcWidth = w - x;
+    }
+
+    if (y + srcHeight > h)
+    {
+        if (static_cast<unsigned>(y) >= h)
+            return;
+
+        srcHeight = h - y;
+    }
+
+    for (unsigned relY = 0; relY < srcHeight; ++relY)
+        for (unsigned relX = 0; relX < srcWidth; ++relX)
+            setPixel(x + relX, y + relY,
+                source.getPixel(srcX + relX, srcY + relY));
+}

data/GosuImpl/Graphics/BitmapBMP.cpp

@@ -0,0 +1,232 @@
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/IO.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/integer.hpp>
+#include <stdexcept>
+
+namespace 
+{
+    typedef std::vector<Gosu::Color> ColorTable;
+
+    void decodePart(unsigned bitCount, Gosu::Bitmap& bmp, Gosu::Reader& reader,
+        boost::uint32_t x, boost::uint32_t y, const ColorTable& colorTable)
+    {
+        if (bitCount == 24)
+        {
+            Gosu::Color color;
+            color.setBlue(reader.getPod<boost::uint8_t>());
+            color.setGreen(reader.getPod<boost::uint8_t>());
+            color.setRed(reader.getPod<boost::uint8_t>());
+            color.setAlpha(255);
+            bmp.setPixel(x, y, color);
+        }
+        else if (bitCount == 8)
+        {
+            boost::uint8_t index;
+            reader.readPod(index);
+            if (index >= colorTable.size())
+                throw std::runtime_error("Bitmap palette index out of range");
+            bmp.setPixel(x, y, colorTable[index]);
+        }
+        else if (bitCount == 4)
+        {
+            boost::uint8_t doubleIndex, index[2];
+            reader.readPod(doubleIndex);
+            index[0] = (doubleIndex & 0xf0) >> 4;
+            index[1] = (doubleIndex & 0x0f);
+            
+            for (int i = 0; i < 2; ++i)
+            {
+                if (index[i] > colorTable.size())
+                    throw std::runtime_error("Bitmap palette index out of range");
+                bmp.setPixel(x + i, y, colorTable[index[i]]);
+            }
+        }
+    }
+    
+    template<unsigned bits>
+    typename boost::uint_t<bits>::fast readVal(Gosu::Reader& reader)
+    {
+    	typename boost::uint_t<bits>::least val;
+        reader.readPod(val, Gosu::boLittle);
+	return val;
+    }
+}
+
+Gosu::Reader Gosu::loadFromBMP(Bitmap& bmp, Reader reader)
+{
+    if (readVal<8>(reader) != 'B' || readVal<8>(reader) != 'M')
+        throw std::runtime_error("File is not a bitmap!");
+
+    // File header
+    // Size
+    readVal<32>(reader);
+    // Reserved
+    readVal<16>(reader);
+    readVal<16>(reader);
+    // Offset to bitmap data
+    readVal<32>(reader);
+    
+    // Info header
+    unsigned infoHeaderSize = readVal<32>(reader);
+    if (infoHeaderSize != 12 && infoHeaderSize != 40)
+        throw std::runtime_error("Unsupported BMP header");
+    bool isOs2Bitmap = infoHeaderSize == 12;
+    
+    unsigned width, height, bitCount, clrUsed;
+    if (isOs2Bitmap)
+    {
+        width = readVal<16>(reader);
+        height = readVal<16>(reader);
+        readVal<16>(reader); // planes
+        bitCount = readVal<16>(reader);
+        clrUsed = 1 << bitCount;
+    }
+    else
+    {
+        width = readVal<32>(reader);
+        height = readVal<32>(reader);
+        readVal<16>(reader); // planes
+        bitCount = readVal<16>(reader);
+        readVal<32>(reader); // compression
+        readVal<32>(reader); // image size
+        readVal<32>(reader); // xPelsPerMeter
+        readVal<32>(reader); // yPelsPerMeter
+        clrUsed = readVal<32>(reader);
+        readVal<32>(reader); // important colors
+    }
+    
+    if (bitCount != 4 && bitCount != 8 && bitCount != 24)
+        throw std::runtime_error("Unsupported BMP file bit depth");
+    
+    bmp.resize(width, height);
+    
+    ColorTable colors;
+    if (bitCount != 24)
+    {
+        if (clrUsed == 0)
+            clrUsed = 1 << bitCount;
+        for (unsigned i = 0; i < clrUsed; ++i)
+        {
+            Gosu::Color color;
+            color.setAlpha(255);
+            color.setBlue(readVal<8>(reader));
+            color.setGreen(readVal<8>(reader));
+            color.setRed(readVal<8>(reader));
+            if (!isOs2Bitmap)
+                readVal<8>(reader); // reserved
+            colors.push_back(color);
+        }
+    }
+    
+    int xOffset = 1;
+    if (bitCount == 4)
+        xOffset = 2;
+
+    unsigned pixelBytesPerRow = 0;
+    switch (bitCount)
+    {
+        case 4: pixelBytesPerRow = (width * 2 + 1) / 2; break;
+        case 8: pixelBytesPerRow = width;
+        case 24: pixelBytesPerRow = width * 3;
+    }
+    unsigned fillBytes = (4 - (pixelBytesPerRow % 4)) % 4;
+    
+    if (bitCount == 24)
+    {
+        // Look-ahead-experiment.
+        // Reducing Reader::read calls => performance on *nix?
+        std::vector<boost::uint8_t> buf(height * (pixelBytesPerRow + fillBytes));
+        boost::uint8_t* ptr = &buf[0];
+        reader.read(ptr, buf.size());
+        for (int y = height - 1; y >= 0; --y)
+        {
+            for (unsigned x = 0; x < width; ++x)
+            {
+                Gosu::Color color;
+                color.setBlue(*ptr++);
+                color.setGreen(*ptr++);
+                color.setRed(*ptr++);
+                color.setAlpha(255);
+                bmp.setPixel(x, y, color);
+            }
+            ptr += fillBytes;
+        }
+    }
+    else
+    for (int y = height - 1; y >= 0; --y)
+    {
+        for (unsigned x = 0; x < width; x += xOffset)
+            decodePart(bitCount, bmp, reader, x, y, colors);
+        
+        reader.seek(fillBytes);
+    }
+    
+    return reader;
+}
+
+namespace
+{
+    template<unsigned bits, typename T>
+    void writeVal(Gosu::Writer& writer, T value)
+    {
+        typename boost::uint_t<bits>::least val = value;
+        writer.writePod(val, Gosu::boLittle);
+    }
+}
+
+Gosu::Writer Gosu::saveToBMP(const Bitmap& bmp, Writer writer)
+{
+    // rowSize is the width ceiled to the next multiple of four.
+    unsigned rowSize = bmp.width() * 3;
+    rowSize = int((float(rowSize) - 1.0)/4.0 + 1.0) * 4;
+    
+    // File header
+    // Type
+    writeVal<8>(writer, 'B');
+    writeVal<8>(writer, 'M');
+    // Size
+    writeVal<32>(writer, 14 + 40 + rowSize * bmp.height());
+    // Reserved
+    writeVal<16>(writer, 0);
+    writeVal<16>(writer, 0);
+    // Offset to data
+    writeVal<32>(writer, 14 + 40);
+        
+    // Info header
+    // Size
+    writeVal<32>(writer, 40);
+    // Width, height
+    writeVal<32>(writer, bmp.width());
+    writeVal<32>(writer, bmp.height());
+    // Planes
+    writeVal<16>(writer, 1);
+    // Bit count
+    writeVal<16>(writer, 24);
+    // Compression
+    writeVal<32>(writer, 0);
+    // Image size
+    writeVal<32>(writer, rowSize * bmp.height());
+    // xPelsPerMeter/yPelsPerMeter
+    writeVal<32>(writer, 0);
+    writeVal<32>(writer, 0);
+    // Used and important colors
+    writeVal<32>(writer, 0);
+    writeVal<32>(writer, 0);
+        
+    for (int y = bmp.height() - 1; y >= 0; y--)
+    {
+        for (unsigned x = 0; x < bmp.width(); x++)
+        {
+            // BGR order
+            writeVal<8>(writer, bmp.getPixel(x, y).blue());
+            writeVal<8>(writer, bmp.getPixel(x, y).green());
+            writeVal<8>(writer, bmp.getPixel(x, y).red());
+        }
+        int offset = rowSize - bmp.width() * 3;
+        for(int i = 0; i < offset; ++i)
+            writeVal<8>(writer, 0);
+    }
+    return writer;
+}
+

data/GosuImpl/Graphics/BitmapColorKey.cpp

@@ -0,0 +1,39 @@
+#include <Gosu/Bitmap.hpp>
+#include <vector>
+
+void Gosu::applyColorKey(Bitmap& bitmap, Color key)
+{
+    std::vector<Color> surroundingColors;
+    surroundingColors.reserve(4);
+
+    for (unsigned y = 0; y < bitmap.height(); ++y)
+        for (unsigned x = 0; x < bitmap.width(); ++x)
+            if (bitmap.getPixel(x, y) == key)
+            {
+                surroundingColors.clear();
+                if (x > 0 && bitmap.getPixel(x - 1, y) != key)
+                    surroundingColors.push_back(bitmap.getPixel(x - 1, y));
+                if (x < bitmap.width() - 1 && bitmap.getPixel(x + 1, y) != key)
+                    surroundingColors.push_back(bitmap.getPixel(x + 1, y));
+                if (y > 0 && bitmap.getPixel(x, y - 1) != key)
+                    surroundingColors.push_back(bitmap.getPixel(x, y - 1));
+                if (y < bitmap.height() - 1 && bitmap.getPixel(x, y + 1) != key)
+                    surroundingColors.push_back(bitmap.getPixel(x, y + 1));
+
+                if (surroundingColors.empty())
+                {
+                    bitmap.setPixel(x, y, Colors::none);
+                    continue;
+                }
+
+                unsigned red = 0, green = 0, blue = 0;
+                for (unsigned i = 0; i < surroundingColors.size(); ++i)
+                {
+                    red += surroundingColors[i].red();
+                    green += surroundingColors[i].green();
+                    blue += surroundingColors[i].blue();
+                }
+                bitmap.setPixel(x, y, Color(0, red / surroundingColors.size(),
+                    green / surroundingColors.size(), blue / surroundingColors.size()));
+            }
+}