gosu 0.7.10.1

data/GosuImpl/Graphics/Graphics.cpp

@@ -0,0 +1,295 @@
+#include <Gosu/Graphics.hpp>
+#include <GosuImpl/Graphics/Common.hpp>
+#include <GosuImpl/Graphics/DrawOp.hpp>
+#include <GosuImpl/Graphics/Texture.hpp>
+#include <GosuImpl/Graphics/TexChunk.hpp>
+#include <GosuImpl/Graphics/LargeImageData.hpp>
+#include <Gosu/Bitmap.hpp>
+#if 0
+#include <boost/thread.hpp>
+#endif
+#include <cmath>
+
+struct Gosu::Graphics::Impl
+{
+    unsigned physWidth, physHeight;
+    unsigned virtWidth, virtHeight;
+    double factorX, factorY;
+    bool fullscreen;
+    DrawOpQueue queue;
+    typedef std::vector<boost::shared_ptr<Texture> > Textures;
+    Textures textures;
+#if 0
+    boost::mutex texMutex;
+#endif
+};
+
+Gosu::Graphics::Graphics(unsigned physWidth, unsigned physHeight, bool fullscreen)
+: pimpl(new Impl)
+{
+    pimpl->physWidth  = pimpl->virtWidth  = physWidth;
+    pimpl->physHeight = pimpl->virtHeight = physHeight;
+    pimpl->factorX = pimpl->factorY = 1.0;
+    pimpl->fullscreen = fullscreen;
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glViewport(0, 0, pimpl->physWidth, pimpl->physHeight);
+    glOrtho(0, pimpl->virtWidth, pimpl->virtHeight, 0, -1, 1);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+
+    glEnable(GL_BLEND);
+}
+
+Gosu::Graphics::~Graphics()
+{
+}
+
+unsigned Gosu::Graphics::width() const
+{
+    return pimpl->virtWidth;
+}
+
+unsigned Gosu::Graphics::height() const
+{
+    return pimpl->virtHeight;
+}
+
+bool Gosu::Graphics::fullscreen() const
+{
+    return pimpl->fullscreen;
+}
+
+double Gosu::Graphics::factorX() const
+{
+    return pimpl->factorX;
+}
+
+double Gosu::Graphics::factorY() const
+{
+    return pimpl->factorY;
+}
+
+void Gosu::Graphics::setResolution(unsigned virtualWidth, unsigned virtualHeight)
+{
+    if (virtualWidth * virtualHeight < 1)
+        throw std::invalid_argument("Invalid virtual resolution.");
+
+    pimpl->virtWidth = virtualWidth;
+    pimpl->virtHeight = virtualHeight;
+    pimpl->factorX = 1.0 / virtualWidth * pimpl->physWidth;
+    pimpl->factorY = 1.0 / virtualHeight * pimpl->physHeight;
+}
+
+bool Gosu::Graphics::begin(Gosu::Color clearWithColor)
+{
+    // Flush leftover clippings
+    endClipping();
+
+    glClearColor(clearWithColor.red()/255.0,
+                 clearWithColor.green()/255.0,
+                 clearWithColor.blue()/255.0,
+                 clearWithColor.alpha()/255.0);
+    glClear(GL_COLOR_BUFFER_BIT);
+    
+    return true;
+}
+
+void Gosu::Graphics::end()
+{
+    pimpl->queue.performDrawOps();
+    glFlush();
+}
+
+void Gosu::Graphics::beginGL()
+{
+    pimpl->queue.performDrawOps();
+    glPushAttrib(GL_ALL_ATTRIB_BITS);
+    glDisable(GL_BLEND);
+}
+
+void Gosu::Graphics::endGL()
+{
+    glPopAttrib();
+
+    // Restore matrices.
+    
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glViewport(0, 0, pimpl->physWidth, pimpl->physHeight);
+    glOrtho(0, pimpl->virtWidth, pimpl->virtHeight, 0, -1, 1);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glEnable(GL_BLEND);
+}
+
+void Gosu::Graphics::beginClipping(int x, int y, unsigned width, unsigned height)
+{
+    // In doubt, make the clipping region smaller than requested.
+    
+    int physX = static_cast<int>(std::ceil(x * factorX()));
+    int physY = static_cast<int>(std::ceil((0.0 + this->height() - y - height) * factorY()));
+    unsigned physWidth  = static_cast<unsigned>(width  * factorX());
+    unsigned physHeight = static_cast<unsigned>(height * factorY());
+
+    pimpl->queue.beginClipping(physX, physY, physWidth, physHeight);
+}
+
+void Gosu::Graphics::endClipping()
+{
+    pimpl->queue.endClipping();
+}
+
+void Gosu::Graphics::drawLine(double x1, double y1, Color c1,
+    double x2, double y2, Color c2,
+    ZPos z, AlphaMode mode)
+{
+    DrawOp op;
+    
+    x1 *= factorX();
+    y1 *= factorY();
+    x2 *= factorX();
+    y2 *= factorY();
+
+    op.mode = mode;
+    op.usedVertices = 2;
+    op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
+    op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
+
+    pimpl->queue.addDrawOp(op, z);
+}
+
+void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
+    double x2, double y2, Color c2,
+    double x3, double y3, Color c3,
+    ZPos z, AlphaMode mode)
+{
+    DrawOp op;
+
+    x1 *= factorX();
+    y1 *= factorY();
+    x2 *= factorX();
+    y2 *= factorY();
+    x3 *= factorX();
+    y3 *= factorY();
+
+    op.mode = mode;
+    op.usedVertices = 3;
+    op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
+    op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
+    op.vertices[2] = DrawOp::Vertex(x3, y3, c3);
+
+    pimpl->queue.addDrawOp(op, z);
+}
+
+void Gosu::Graphics::drawQuad(double x1, double y1, Color c1,
+    double x2, double y2, Color c2,
+    double x3, double y3, Color c3,
+    double x4, double y4, Color c4,
+    ZPos z, AlphaMode mode)
+{
+    DrawOp op;
+
+    x1 *= factorX();
+    y1 *= factorY();
+    x2 *= factorX();
+    y2 *= factorY();
+    x3 *= factorX();
+    y3 *= factorY();
+    x4 *= factorX();
+    y4 *= factorY();
+
+    op.mode = mode;
+    op.usedVertices = 4;
+    op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
+    op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
+    op.vertices[3] = DrawOp::Vertex(x3, y3, c3);
+    op.vertices[2] = DrawOp::Vertex(x4, y4, c4);
+
+    pimpl->queue.addDrawOp(op, z);
+}
+
+std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(
+    const Bitmap& src, unsigned srcX, unsigned srcY,
+    unsigned srcWidth, unsigned srcHeight, unsigned borderFlags)
+{
+    static const unsigned maxSize = Texture::maxTextureSize();
+
+    // Special case: If the texture is supposed to have hard borders,
+    // is quadratic, has a size that is at least 64 pixels but less than 256
+    // pixels and a power of two, create a single texture just for this image.
+    /*if ((borderFlags & bfHard) == bfHard &&
+        srcWidth == srcHeight &&
+        srcWidth >= 64 && srcWidth <= 256 &&
+        (srcWidth & (srcWidth - 1)) == 0)
+    {
+        boost::shared_ptr<Texture> texture(new Texture(srcWidth));
+        std::auto_ptr<ImageData> data;
+        
+        // Use the source bitmap directly if the source area completely covers
+        // it.
+        if (srcX == 0 && srcWidth == src.width() &&
+            srcY == 0 && srcHeight == src.height())
+        {
+            data = texture->tryAlloc(*this, pimpl->queue, texture,
+                    src, 0, 0, src.width(), src.height(), 0);
+        }
+        else
+        {
+            Bitmap trimmedSrc;
+            trimmedSrc.resize(srcWidth, srcHeight);
+            trimmedSrc.insert(src, 0, 0, srcX, srcY, srcWidth, srcHeight);
+            data = texture->tryAlloc(*this, pimpl->queue, texture,
+                    trimmedSrc, 0, 0, trimmedSrc.width(), trimmedSrc.height(), 0);
+        }
+        
+        if (!data.get())
+            throw std::logic_error("Internal texture block allocation error");
+        return data;
+    }*/
+    
+    // Too large to fit on a single texture. 
+    if (srcWidth > maxSize - 2 || srcHeight > maxSize - 2)
+    {
+        Bitmap bmp;
+        bmp.resize(srcWidth, srcHeight);
+        bmp.insert(src, 0, 0, srcX, srcY, srcWidth, srcHeight);
+        std::auto_ptr<ImageData> lidi;
+        lidi.reset(new LargeImageData(*this, bmp, maxSize - 2, maxSize - 2, borderFlags));
+        return lidi;
+    }
+    
+    Bitmap bmp;
+    applyBorderFlags(bmp, src, srcX, srcY, srcWidth, srcHeight, borderFlags);
+
+#if 0
+    boost::mutex::scoped_lock lock(pimpl->texMutex);
+#endif
+    
+    // Try to put the bitmap into one of the already allocated textures.
+    for (Impl::Textures::iterator i = pimpl->textures.begin(); i != pimpl->textures.end(); ++i)
+    {
+        boost::shared_ptr<Texture> texture(*i);
+        
+        std::auto_ptr<ImageData> data;
+        data = texture->tryAlloc(*this, pimpl->queue, texture, bmp, 0, 0, bmp.width(), bmp.height(), 1);
+        if (data.get())
+            return data;
+    }
+    
+    // All textures are full: Create a new one.
+    
+    boost::shared_ptr<Texture> texture;
+    texture.reset(new Texture(maxSize));
+    pimpl->textures.push_back(texture);
+    
+    std::auto_ptr<ImageData> data;
+    data = texture->tryAlloc(*this, pimpl->queue, texture, bmp, 0, 0, bmp.width(), bmp.height(), 1);
+    if (!data.get())
+        throw std::logic_error("Internal texture block allocation error");
+
+    return data;
+}

data/GosuImpl/Graphics/Image.cpp

@@ -0,0 +1,159 @@
+#include <Gosu/Image.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/ImageData.hpp>
+#include <Gosu/Math.hpp>
+#include <Gosu/IO.hpp>
+
+Gosu::Image::Image(Graphics& graphics, const std::wstring& filename, bool hardBorders)
+{
+	// Forward.
+	Image(graphics, quickLoadBitmap(filename), hardBorders).data.swap(data);
+}
+
+Gosu::Image::Image(Graphics& graphics, const std::wstring& filename,
+    unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
+    bool hardBorders)
+{
+	// Forward.
+	Image(graphics, quickLoadBitmap(filename), srcX, srcY, srcWidth, srcHeight, hardBorders).data.swap(data);
+}
+
+Gosu::Image::Image(Graphics& graphics, const Bitmap& source, bool hardBorders)
+{
+	// Forward.
+	Image(graphics, source, 0, 0, source.width(), source.height(), hardBorders).data.swap(data);
+}
+
+Gosu::Image::Image(Graphics& graphics, const Bitmap& source,
+    unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
+    bool hardBorders)
+: data(graphics.createImage(source, srcX, srcY, srcWidth, srcHeight,
+    hardBorders ? Gosu::bfHard : Gosu::bfSoft))
+{
+}
+
+Gosu::Image::~Image()
+{
+}
+
+unsigned Gosu::Image::width() const
+{
+    return data->width();
+}
+
+unsigned Gosu::Image::height() const
+{
+    return data->height();
+}
+
+void Gosu::Image::draw(double x, double y, ZPos z,
+    double factorX, double factorY,
+    Color c,
+    AlphaMode mode) const
+{
+    double x2 = x + width() * factorX;
+    double y2 = y + height() * factorY;
+
+    data->draw(x, y, c, x2, y, c, x, y2, c, x2, y2, c, z, mode);
+}
+
+void Gosu::Image::drawMod(double x, double y, ZPos z,
+    double factorX, double factorY,
+    Color c1, Color c2, Color c3, Color c4,
+    AlphaMode mode) const
+{
+    double x2 = x + width() * factorX;
+    double y2 = y + height() * factorY;
+
+    data->draw(x, y, c1, x2, y, c2, x, y2, c3, x2, y2, c4, z, mode);
+}
+
+void Gosu::Image::drawRot(double x, double y, ZPos z,
+    double angle, double centerX, double centerY,
+    double factorX, double factorY,
+    Color c,
+    AlphaMode mode) const
+{
+    double sizeX = width()  * factorX;
+    double sizeY = height() * factorY;
+    double offsX = offsetX(angle, 1);
+    double offsY = offsetY(angle, 1);
+
+    // Offset to the centers of the original Image's edges when it is rotated
+    // by <angle> degrees.
+    double distToLeftX   = +offsY * sizeX * centerX;
+    double distToLeftY   = -offsX * sizeX * centerX;
+    double distToRightX  = -offsY * sizeX * (1 - centerX);
+    double distToRightY  = +offsX * sizeX * (1 - centerX);
+    double distToTopX    = +offsX * sizeY * centerY;
+    double distToTopY    = +offsY * sizeY * centerY;
+    double distToBottomX = -offsX * sizeY * (1 - centerY);
+    double distToBottomY = -offsY * sizeY * (1 - centerY);
+
+    data->draw(x + distToLeftX  + distToTopX,
+               y + distToLeftY  + distToTopY, c,
+               x + distToRightX + distToTopX,
+               y + distToRightY + distToTopY, c,
+               x + distToLeftX  + distToBottomX,
+               y + distToLeftY  + distToBottomY, c,
+               x + distToRightX + distToBottomX,
+               y + distToRightY + distToBottomY,
+               c, z, mode);
+}
+
+void Gosu::Image::drawRotFlip(double x, double y, ZPos z,
+    RotFlip rf,
+    double factorX, double factorY,
+    Color c,
+    AlphaMode mode) const
+{
+    drawRotFlipMod(x, y, z, rf, factorX, factorY, c, c, c, c, mode);
+}
+
+void Gosu::Image::drawRotFlipMod(double x, double y, ZPos z,
+    RotFlip rf,
+    double factorX, double factorY,
+    Color c1, Color c2, Color c3, Color c4,
+    AlphaMode mode) const
+{
+    double offsetX;
+    double offsetY;
+
+    if (rf.rotated())
+    {
+        offsetX = height() * factorY / 2;
+        offsetY = width() * factorX / 2;
+    }
+    else
+    {
+        offsetX = width() * factorX / 2;
+        offsetY = height() * factorY / 2;
+    }
+
+    struct Point
+    {
+        double x, y;
+    };
+
+    Point corners[4] = { { x - offsetX, y - offsetY },
+                         { x + offsetX, y - offsetY },
+                         { x - offsetX, y + offsetY },
+                         { x + offsetX, y + offsetY } };
+
+    Point* vertices[4] =
+        { &corners[rf.mapCorner(0)], &corners[rf.mapCorner(1)],
+          &corners[rf.mapCorner(2)], &corners[rf.mapCorner(3)] };
+
+    data->draw(
+        vertices[0]->x, vertices[0]->y, c1,
+        vertices[1]->x, vertices[1]->y, c2,
+        vertices[2]->x, vertices[2]->y, c3,
+        vertices[3]->x, vertices[3]->y, c4,
+        z, mode);
+}
+
+const Gosu::ImageData& Gosu::Image::getData() const
+{
+    return *data;
+}