gosu 0.7.10.1

data/GosuImpl/Graphics/BlockAllocator.hpp

@@ -0,0 +1,34 @@
+#ifndef GOSUIMPL_BLOCKALLOCATOR_HPP
+#define GOSUIMPL_BLOCKALLOCATOR_HPP
+
+#include <boost/optional.hpp>
+#include <boost/scoped_ptr.hpp>
+
+namespace Gosu
+{
+    class BlockAllocator
+    {
+        struct Impl;
+        boost::scoped_ptr<Impl> pimpl;
+
+    public:
+        struct Block
+        {
+            unsigned left, top, width, height;
+            Block() {}
+            Block(unsigned aLeft, unsigned aTop, unsigned aWidth, unsigned aHeight)
+            : left(aLeft), top(aTop), width(aWidth), height(aHeight) {}
+        };
+    
+        BlockAllocator(unsigned width, unsigned height);
+        ~BlockAllocator();
+
+        unsigned width() const;
+        unsigned height() const;
+
+        boost::optional<Block> alloc(unsigned width, unsigned height);
+        void free(unsigned left, unsigned top);
+    };
+}
+
+#endif

data/GosuImpl/Graphics/Color.cpp

@@ -0,0 +1,126 @@
+#include <Gosu/Color.hpp>
+#include <Gosu/Math.hpp>
+#include <algorithm>
+
+namespace
+{
+    struct HSV { double h, s, v; };
+    
+    HSV colorToHSV(const Gosu::Color& c)
+    {
+        double r = c.red() / 255.0;
+        double g = c.green() / 255.0;
+        double b = c.blue() / 255.0;
+        
+        double min = std::min(std::min(r, g), b);
+        double max = std::max(std::max(r, g), b);
+
+        if (max == 0)
+        {
+            HSV hsv = { 0, 0, 0 };
+            return hsv;
+        }
+        
+        // Value.
+        HSV hsv = { -1, -1, max };
+        
+        // Saturation.
+        double delta = max - min;
+        hsv.s = delta / max;
+        
+        // Hue.
+        if (r == max)
+            hsv.h = (g - b) / delta + (g < b ? 6 : 0);
+        else if (g == max)
+            hsv.h = (b - r) / delta + 2;
+        else
+            hsv.h = (r - g) / delta + 4;
+        hsv.h *= 60;
+        
+        return hsv;
+    }
+}
+
+Gosu::Color Gosu::Color::fromHSV(double h, double s, double v)
+{
+    return fromAHSV(255, h, s, v);
+}
+
+Gosu::Color Gosu::Color::fromAHSV(Channel alpha, double h, double s, double v)
+{
+	if (s == 0)
+		// Grey.
+        return Color(alpha, v * 255, v * 255, v * 255);
+    
+    // Normalize hue
+    h = ((static_cast<int>(h) % 360) + 360) % 360;
+    
+	int sector = h / 60;
+    double factorial = h / 60 - sector;
+    
+	double p = v * (1 - s);
+	double q = v * (1 - s * factorial);
+	double t = v * (1 - s * (1 - factorial));
+	
+    switch (sector) 
+    {
+    case 0:
+        return Color(alpha, v * 255, t * 255, p * 255);
+    case 1:
+        return Color(alpha, q * 255, v * 255, p * 255);
+    case 2:
+        return Color(alpha, p * 255, v * 255, t * 255);
+    case 3:
+        return Color(alpha, p * 255, q * 255, v * 255);
+    case 4:
+        return Color(alpha, t * 255, p * 255, v * 255);
+    default: // sector 5
+        return Color(alpha, v * 255, p * 255, q * 255);
+    }
+}
+
+double Gosu::Color::hue() const
+{
+    return colorToHSV(*this).h;
+}
+
+void Gosu::Color::setHue(double h)
+{
+    *this = fromAHSV(alpha(), h, saturation(), value());
+}
+
+double Gosu::Color::saturation() const
+{
+    return colorToHSV(*this).s;
+}
+
+void Gosu::Color::setSaturation(double s)
+{
+    *this = fromAHSV(alpha(), hue(), s, value());
+}
+
+double Gosu::Color::value() const
+{
+    return colorToHSV(*this).v;
+}
+
+void Gosu::Color::setValue(double v)
+{
+    *this = fromAHSV(alpha(), hue(), saturation(), v);
+}
+
+Gosu::Color Gosu::interpolate(Color a, Color b, double weight)
+{
+    return Color(clamp<int>(round(Gosu::interpolate(a.alpha(), b.alpha(), weight)), 0, 255),
+                 clamp<int>(round(Gosu::interpolate(a.red(),   b.red(),   weight)), 0, 255),
+                 clamp<int>(round(Gosu::interpolate(a.green(), b.green(), weight)), 0, 255),
+                 clamp<int>(round(Gosu::interpolate(a.blue(),  b.blue(),  weight)), 0, 255));
+}
+
+Gosu::Color Gosu::multiply(Color a, Color b)
+{
+    return Color(round(a.alpha() * b.alpha() / 255.0),
+                 round(a.red()   * b.red()   / 255.0),
+                 round(a.green() * b.green() / 255.0),
+                 round(a.blue()  * b.blue()  / 255.0));
+}

data/GosuImpl/Graphics/Common.hpp

@@ -0,0 +1,21 @@
+#ifndef GOSUIMPL_GRAPHICS_COMMON_HPP
+#define GOSUIMPL_GRAPHICS_COMMON_HPP
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#else
+#include <GL/gl.h>
+#endif
+
+namespace Gosu
+{
+    class Texture;
+    class TexChunk;
+    struct DrawOp;
+    class DrawOpQueue;
+}
+
+#endif

data/GosuImpl/Graphics/DrawOp.hpp

@@ -0,0 +1,154 @@
+#ifndef GOSUIMPL_DRAWOP_HPP
+#define GOSUIMPL_DRAWOP_HPP
+
+#include <Gosu/GraphicsBase.hpp>
+#include <Gosu/Color.hpp>
+#include <GosuImpl/Graphics/Common.hpp>
+#include <GosuImpl/Graphics/TexChunk.hpp>
+#include <set>
+
+namespace Gosu
+{
+    struct DrawOp
+    {
+        int clipX, clipY;
+        unsigned clipWidth, clipHeight;
+            
+        struct Vertex
+        {
+            double x, y;
+            Color c;
+            Vertex() {}
+            Vertex(double x, double y, Color c) : x(x), y(y), c(c) {}
+        };
+
+        ZPos z;
+        Vertex vertices[4];
+        unsigned usedVertices;
+        const TexChunk* chunk;
+        AlphaMode mode;
+
+        DrawOp() { clipWidth = 0xffffffff; usedVertices = 0; chunk = 0; }
+        
+        void perform() const
+        {
+            if (clipWidth != 0xffffffff)
+            {
+                glEnable(GL_SCISSOR_TEST);
+                glScissor(clipX, clipY, clipWidth, clipHeight);
+            }
+        
+            if (mode == amAdditive)
+                glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+            else
+                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+            if (chunk)
+            {
+                glEnable(GL_TEXTURE_2D);
+                glBindTexture(GL_TEXTURE_2D, chunk->texName());
+            }
+
+            if (usedVertices == 2)
+                glBegin(GL_LINES);
+            else if (usedVertices == 3)
+                glBegin(GL_TRIANGLES);
+            else if (usedVertices == 4)
+                glBegin(GL_QUADS);
+
+            double left, top, right, bottom;
+            if (chunk)
+                chunk->getCoords(left, top, right, bottom);
+
+            for (unsigned i = 0; i < usedVertices; i++)
+            {
+                glColor4f(vertices[i].c.red() / 255.0, vertices[i].c.green() / 255.0,
+                          vertices[i].c.blue() / 255.0, vertices[i].c.alpha() / 255.0);
+                if (chunk)
+                    switch (i)
+                    {
+                    case 0:
+                        glTexCoord2d(left, top);
+                        break;
+                    case 1:
+                        glTexCoord2d(right, top);
+                        break;
+                    case 2:
+                        glTexCoord2d(right, bottom);
+                        break;
+                    case 3:
+                        glTexCoord2d(left, bottom);
+                        break;
+                    }
+                glVertex2d(vertices[i].x, vertices[i].y);
+            }
+
+            glEnd();
+
+            if (chunk)
+                glDisable(GL_TEXTURE_2D);
+
+            if (clipWidth != 0xffffffff)
+                glDisable(GL_SCISSOR_TEST);
+        }
+        
+        bool operator<(const DrawOp& other) const
+        {
+            return z < other.z; // optimization starts TODAY
+        }
+    };
+
+    class DrawOpQueue
+    {
+        int clipX, clipY;
+        unsigned clipWidth, clipHeight;
+        std::multiset<DrawOp> set;
+
+    public:
+        DrawOpQueue()
+        : clipWidth(0xffffffff)
+        {
+        }
+    
+        void addDrawOp(DrawOp op, ZPos z)
+        {
+            op.z = z;
+            if (clipWidth != 0xffffffff)
+            {
+                op.clipX = clipX;
+                op.clipY = clipY;
+                op.clipWidth = clipWidth;
+                op.clipHeight = clipHeight;
+            }
+            set.insert(op);
+        }
+        
+        void beginClipping(int x, int y, unsigned width, unsigned height)
+        {
+            clipX = x;
+            clipY = y;
+            clipWidth = width;
+            clipHeight = height;
+        }
+        
+        void endClipping()
+        {
+            clipWidth = 0xffffffff;
+        }
+
+        void performDrawOps()
+        {
+            std::multiset<DrawOp>::iterator cur = set.begin(), end = set.end();
+            while (cur != end)
+            {
+                cur->perform();
+                ++cur;
+            }
+            set.clear();
+        }
+    };
+}
+
+#endif
+
+

data/GosuImpl/Graphics/Font.cpp

@@ -0,0 +1,110 @@
+#include <Gosu/Font.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Image.hpp>
+#include <Gosu/Math.hpp>
+#include <Gosu/Text.hpp>
+#include <boost/array.hpp>
+using namespace std;
+
+struct Gosu::Font::Impl
+{
+    Graphics* graphics;
+    wstring fontName;
+    unsigned height;
+
+    // Chunk of 2^16 characters (on Windows, there'll only be one of them).
+    // IMPR: I couldn't find a way to determine the size of wchar_t at compile
+    // time, so I can't get rid of the magic numbers or even do some #ifdef
+    // magic.
+    typedef boost::array<boost::scoped_ptr<Image>, 65536> CharChunk;
+    boost::scoped_ptr<CharChunk> chunks[65536];
+
+    Image& getChar(wchar_t wc)
+    {
+        size_t chunkIndex = wc / 65536;
+        size_t charIndex = wc % 65536;
+
+        if (!chunks[chunkIndex])
+            chunks[chunkIndex].reset(new CharChunk);
+
+        boost::scoped_ptr<Image>& imgPtr = (*chunks[chunkIndex])[charIndex];
+
+        if (imgPtr)
+            return *imgPtr;
+
+        wstring charString(1, wc);
+        unsigned charWidth = Gosu::textWidth(charString, fontName, height, ffBold);
+        Bitmap bmp;
+        bmp.resize(charWidth, height);
+        
+        drawText(bmp, charString, 0, 0, Colors::white, fontName, height, ffBold);
+        imgPtr.reset(new Image(*graphics, bmp));
+        return *imgPtr;
+    }
+};
+
+Gosu::Font::Font(Graphics& graphics, const wstring& fontName, unsigned height)
+: pimpl(new Impl)
+{
+    pimpl->graphics = &graphics;
+    pimpl->fontName = fontName;
+    pimpl->height = height * 2; // Auto-AA!
+}
+
+Gosu::Font::~Font()
+{
+}
+
+unsigned Gosu::Font::height() const
+{
+    return pimpl->height / 2;
+}
+
+double Gosu::Font::textWidth(const std::wstring& text, double factorX) const
+{
+    double result = 0;
+    for (unsigned i = 0; i < text.length(); ++i)
+        result += pimpl->getChar(text[i]).width();
+    return result * factorX / 2;
+}
+
+void Gosu::Font::draw(const wstring& text, double x, double y, ZPos z,
+    double factorX, double factorY, Color c, AlphaMode mode) const
+{
+    factorX /= 2;
+    factorY /= 2;
+
+    for (unsigned i = 0; i < text.length(); ++i)
+    {
+        Image& curChar = pimpl->getChar(text[i]);
+        curChar.draw(x, y, z, factorX, factorY, c, mode);
+        x += curChar.width() * factorX;
+    }
+}
+                     
+void Gosu::Font::drawRel(const wstring& text, double x, double y, ZPos z,
+    double relX, double relY, double factorX, double factorY, Color c,
+    AlphaMode mode) const
+{
+    x -= textWidth(text) * factorX * relX;
+    y -= height() * factorY * relY;
+
+    draw(text, x, y, z, factorX, factorY, c, mode);
+}
+
+void Gosu::Font::drawRot(const wstring& text, double x, double y, ZPos z, double angle,
+    double factorX, double factorY, Color c, AlphaMode mode) const
+{
+    factorX /= 2;
+    factorY /= 2;
+    
+    double stepX = offsetX(angle + 90, 1.0), stepY = offsetY(angle + 90, 1.0);
+
+    for (unsigned i = 0; i < text.length(); ++i)
+    {
+        Image& curChar = pimpl->getChar(text[i]);
+        curChar.drawRot(x, y, z, angle, 0.0, 0.0, factorX, factorY, c, mode);
+        x += curChar.width() * factorX * stepX;
+        y += curChar.width() * factorX * stepY;
+    }
+}