gosu 0.7.10.1

data/GosuImpl/Graphics/LargeImageData.cpp

@@ -0,0 +1,115 @@
+#include <GosuImpl/Graphics/LargeImageData.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Math.hpp>
+#include <cmath>
+using namespace std;
+
+Gosu::LargeImageData::LargeImageData(Graphics& graphics,
+    const Bitmap& source, unsigned partWidth, unsigned partHeight,
+    unsigned borderFlags)
+{
+    fullWidth = source.width();
+    fullHeight = source.height();
+    partsX = trunc(ceil(1.0 * source.width() / partWidth));
+    partsY = trunc(ceil(1.0 * source.height() / partHeight));
+    this->partWidth = partWidth;
+    this->partHeight = partHeight;
+
+    parts.resize(partsX * partsY);
+
+    for (unsigned y = 0; y < partsY; ++y)
+        for (unsigned x = 0; x < partsX; ++x)
+        {
+            // The right-most parts don't necessarily have the full width.
+            unsigned srcWidth = partWidth;
+            if (x == partsX - 1 && source.width() % partWidth != 0)
+                srcWidth = source.width() % partWidth;
+
+            // Same for the parts on the bottom.
+            unsigned srcHeight = partHeight;
+            if (y == partsY - 1 && source.height() % partHeight != 0)
+                srcHeight = source.height() % partHeight;
+
+            unsigned localBorderFlags = bfHard;
+            if (x == 0)
+                localBorderFlags &= ~(borderFlags & bfHardLeft);
+            else if (x == partsX - 1)
+                localBorderFlags &= ~(borderFlags & bfHardRight);
+            if (y == 0)
+                localBorderFlags &= ~(borderFlags & bfHardTop);
+            else if (y == partsY - 1)
+                localBorderFlags &= ~(borderFlags & bfHardBottom);
+
+            parts[y * partsX + x].reset(graphics.createImage(source,
+                x * partWidth, y * partHeight, srcWidth, srcHeight,
+                localBorderFlags).release());
+        }
+}
+
+unsigned Gosu::LargeImageData::width() const
+{
+    return fullWidth;
+}
+
+unsigned Gosu::LargeImageData::height() const
+{
+    return fullHeight;
+}
+
+namespace
+{
+    // Local interpolation helper functions.
+
+    double ipl(double a, double b, double ratio)
+    {
+        return a + (b - a) * ratio;
+    }
+
+    Gosu::Color ipl(Gosu::Color a, Gosu::Color b, double ratio)
+    {
+        Gosu::Color result;
+        result.setAlpha(Gosu::round(ipl(a.alpha(), b.alpha(), ratio)));
+        result.setRed  (Gosu::round(ipl(a.red(),   b.red(),   ratio)));
+        result.setGreen(Gosu::round(ipl(a.green(), b.green(), ratio)));
+        result.setBlue (Gosu::round(ipl(a.blue(),  b.blue(),  ratio)));
+        return result;
+    }
+}
+
+void Gosu::LargeImageData::draw(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) const
+{
+    if (parts.empty())
+        return;
+
+    for (unsigned py = 0; py < partsY; ++py)
+        for (unsigned px = 0; px < partsX; ++px)
+        {
+            const ImageData& part = *parts[py * partsX + px];
+
+            double relXL = static_cast<double>(px * partWidth) / width();
+            double relXR = static_cast<double>(px * partWidth + part.width()) / width();
+            double relYT = static_cast<double>(py * partHeight) / height();
+            double relYB = static_cast<double>(py * partHeight + part.height()) / height();
+
+            double absXTL = ipl(ipl(x1, x3, relYT), ipl(x2, x4, relYT), relXL);
+            double absXTR = ipl(ipl(x1, x3, relYT), ipl(x2, x4, relYT), relXR);
+            double absXBL = ipl(ipl(x1, x3, relYB), ipl(x2, x4, relYB), relXL);
+            double absXBR = ipl(ipl(x1, x3, relYB), ipl(x2, x4, relYB), relXR);
+
+            double absYTL = ipl(ipl(y1, y3, relYT), ipl(y2, y4, relYT), relXL);
+            double absYTR = ipl(ipl(y1, y3, relYT), ipl(y2, y4, relYT), relXR);
+            double absYBL = ipl(ipl(y1, y3, relYB), ipl(y2, y4, relYB), relXL);
+            double absYBR = ipl(ipl(y1, y3, relYB), ipl(y2, y4, relYB), relXR);
+
+            Color absCTL = ipl(ipl(c1, c3, relYT), ipl(c2, c4, relYT), relXL);
+            Color absCTR = ipl(ipl(c1, c3, relYT), ipl(c2, c4, relYT), relXR);
+            Color absCBL = ipl(ipl(c1, c3, relYB), ipl(c2, c4, relYB), relXL);
+            Color absCBR = ipl(ipl(c1, c3, relYB), ipl(c2, c4, relYB), relXR);
+
+            part.draw(absXTL, absYTL, absCTL, absXTR, absYTR, absCTR,
+                absXBL, absYBL, absCBL, absXBR, absYBR, absCBR, z, mode);
+        }
+}

data/GosuImpl/Graphics/LargeImageData.hpp

@@ -0,0 +1,37 @@
+#ifndef GOSUIMPL_LARGEIMAGEDATA_HPP
+#define GOSUIMPL_LARGEIMAGEDATA_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/ImageData.hpp>
+#include <boost/none.hpp>
+#include <boost/shared_ptr.hpp>
+#include <vector>
+
+namespace Gosu
+{
+    class LargeImageData : public ImageData
+    {
+        unsigned fullWidth, fullHeight, partsX, partsY, partWidth, partHeight;
+        std::vector<boost::shared_ptr<ImageData> > parts;
+
+    public:
+        LargeImageData(Graphics& graphics, const Bitmap& source,
+            unsigned partWidth, unsigned partHeight, unsigned borderFlags);
+
+        unsigned width() const;
+        unsigned height() const;
+
+        void draw(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) const;
+            
+        boost::optional<GLTexInfo> glTexInfo() const
+        {
+            return boost::none;
+        }
+    };
+}
+
+#endif

data/GosuImpl/Graphics/RotFlip.cpp

@@ -0,0 +1,184 @@
+#include <Gosu/RotFlip.hpp>
+#include <algorithm>
+
+const Gosu::RotFlip::TransTable Gosu::RotFlip::flipXTable =
+{
+    // rfDefault ->
+    rfFlipX,
+    // rfRotate90 ->
+    rfRotate90FlipX,
+    // rfRotate180 ->
+    rfRotate180FlipX,
+    // rfRotate270 ->
+    rfRotate270FlipX,
+    // rfFlipX ->
+    rfDefault,
+    // rfRotate90FlipX ->
+    rfRotate90,
+    // rfRotate180FlipX ->
+    rfRotate180,
+    // rfRotate270FlipX ->
+    rfRotate270
+};
+
+const Gosu::RotFlip::TransTable Gosu::RotFlip::flipYTable =
+{
+    // rfDefault ->
+    rfFlipY,
+    // rfRotate90 ->
+    rfRotate90FlipY,
+    // rfRotate180 ->
+    rfRotate180FlipY,
+    // rfRotate270 ->
+    rfRotate270FlipY,
+    // rfFlipX ->
+    rfRotate180,
+    // rfRotate90FlipX ->
+    rfRotate270,
+    // rfRotate180FlipX ->
+    rfDefault,
+    // rfRotate270FlipX ->
+    rfRotate90
+};
+
+const Gosu::RotFlip::TransTable Gosu::RotFlip::rotate90Table =
+{
+    // rfDefault ->
+    rfRotate90,
+    // rfRotate90 ->
+    rfRotate180,
+    // rfRotate180 ->
+    rfRotate270,
+    // rfRotate270 ->
+    rfDefault,
+    // rfFlipX ->
+    rfFlipXRotate90,
+    // rfRotate90FlipX ->
+    rfFlipX,
+    // rfRotate180FlipX ->
+    rfFlipYRotate90,
+    // rfRotate270FlipX ->
+    rfFlipY
+};
+
+const Gosu::RotFlip::TransTable Gosu::RotFlip::rotate180Table =
+{
+    // rfDefault ->
+    rotate90Table[rotate90Table[rfDefault]],
+    // rfRotate90 ->
+    rotate90Table[rotate90Table[rfRotate90]],
+    // rfRotate180 ->
+    rotate90Table[rotate90Table[rfRotate180]],
+    // rfRotate270 ->
+    rotate90Table[rotate90Table[rfRotate270]],
+    // rfFlipX ->
+    rotate90Table[rotate90Table[rfFlipX]],
+    // rfRotate90FlipX ->
+    rotate90Table[rotate90Table[rfRotate90FlipX]],
+    // rfRotate180FlipX ->
+    rotate90Table[rotate90Table[rfRotate180FlipX]],
+    // rfRotate270FlipX ->
+    rotate90Table[rotate90Table[rfRotate270FlipX]],
+};
+
+const Gosu::RotFlip::TransTable Gosu::RotFlip::rotate270Table =
+{
+    // rfDefault ->
+    rotate90Table[rotate180Table[rfDefault]],
+    // rfRotate90 ->
+    rotate90Table[rotate180Table[rfRotate90]],
+    // rfRotate180 ->
+    rotate90Table[rotate180Table[rfRotate180]],
+    // rfRotate270 ->
+    rotate90Table[rotate180Table[rfRotate270]],
+    // rfFlipX ->
+    rotate90Table[rotate180Table[rfFlipX]],
+    // rfRotate90FlipX ->
+    rotate90Table[rotate180Table[rfRotate90FlipX]],
+    // rfRotate180FlipX ->
+    rotate90Table[rotate180Table[rfRotate180FlipX]],
+    // rfRotate270FlipX ->
+    rotate90Table[rotate180Table[rfRotate270FlipX]],
+};
+
+const Gosu::RotFlip::CornerTable Gosu::RotFlip::mapCornerTable =
+{
+    // rfDefault ->
+    { 0, 1, 2, 3 },
+    // rfRotate90 ->
+    { 1, 3, 0, 2 },
+    // rfRotate180 ->
+    { 3, 2, 1, 0 },
+    // rfRotate270 ->
+    { 2, 0, 3, 1 },
+    // rfFlipX ->
+    { 1, 0, 3, 2 },
+    // rfRotate90FlipX ->
+    { 0, 2, 1, 3 },
+    // rfRotate180FlipX ->
+    { 2, 3, 0, 1 },
+    // rfRotate270FlipX ->
+    { 3, 1, 2, 0 }
+};
+
+const Gosu::RotFlip::CornerTable Gosu::RotFlip::realCornerTable =
+{
+    // rfDefault ->
+    { 0, 1, 2, 3 },
+    // rfRotate90 ->
+    { 1, 3, 0, 2 },
+    // rfRotate180 ->
+    { 3, 2, 1, 0 },
+    // rfRotate270 ->
+    { 1, 3, 0, 2 },
+    // rfFlipX ->
+    { 1, 0, 3, 2 },
+    // rfRotate90FlipX ->
+    { 3, 1, 2, 0 },
+    // rfRotate180FlipX ->
+    { 2, 3, 0, 1 },
+    // rfRotate270FlipX ->
+    { 0, 2, 1, 3 }
+};
+
+void Gosu::applyToPoint(Gosu::RotFlip rotFlip, int& x, int& y, int max)
+{
+    switch (rotFlip.name())
+    {
+    case rfDefault:
+        return;
+
+    case rfRotate90:
+        std::swap(x, y);
+        y = max - y;
+        return;
+
+    case rfRotate180:
+        x = max - x;
+        y = max - y;
+        return;
+
+    case rfRotate270:
+        std::swap(x, y);
+        x = max - x;
+        return;
+
+    case rfFlipX:
+        x = max - x;
+        return;
+
+    case rfRotate90FlipX:
+        std::swap(x, y);
+        return;
+
+    case rfRotate180FlipX: // == rfFlipY
+        y = max - y;
+        return;
+
+    case rfRotate270FlipX:
+        int temp = x;
+        x = max - y;
+        y = max - temp;
+        return;
+    }
+}

data/GosuImpl/Graphics/TexChunk.cpp

@@ -0,0 +1,77 @@
+#include <GosuImpl/Graphics/TexChunk.hpp>
+#include <GosuImpl/Graphics/Texture.hpp>
+#include <GosuImpl/Graphics/DrawOp.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Graphics.hpp>
+
+Gosu::TexChunk::TexChunk(Graphics& graphics, DrawOpQueue& queue,
+                                 boost::shared_ptr<Texture> texture,
+                                 int x, int y, int w, int h, int padding)
+: graphics(&graphics), queue(&queue), texture(texture), x(x), y(y), w(w), h(h), padding(padding)
+{
+}
+
+Gosu::TexChunk::~TexChunk()
+{
+    texture->free(x - padding, y - padding);
+}
+
+unsigned int Gosu::TexChunk::width() const
+{
+    return w;
+}
+
+unsigned int Gosu::TexChunk::height() const
+{
+    return h;
+}
+
+GLuint Gosu::TexChunk::texName() const
+{
+    return texture->texName();
+}
+
+void Gosu::TexChunk::getCoords(double& left, double& top, double& right, double& bottom) const
+{
+    left = double(x) / texture->size();
+    top = double(y) / texture->size();
+    right = double(x + w) / texture->size();
+    bottom = double(y + h) / texture->size();
+}
+
+void Gosu::TexChunk::draw(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) const
+{
+    DrawOp newDrawOp;
+
+    x1 *= graphics->factorX();
+    y1 *= graphics->factorY();
+    x2 *= graphics->factorX();
+    y2 *= graphics->factorY();
+    x3 *= graphics->factorX();
+    y3 *= graphics->factorY();
+    x4 *= graphics->factorX();
+    y4 *= graphics->factorY();
+    
+    newDrawOp.usedVertices = 4;
+    newDrawOp.vertices[0] = DrawOp::Vertex(x1, y1, c1);
+    newDrawOp.vertices[1] = DrawOp::Vertex(x2, y2, c2);
+    newDrawOp.vertices[3] = DrawOp::Vertex(x3, y3, c3);
+    newDrawOp.vertices[2] = DrawOp::Vertex(x4, y4, c4);
+    newDrawOp.chunk = this;
+    newDrawOp.mode = mode;
+
+    queue->addDrawOp(newDrawOp, z);
+}
+
+
+boost::optional<Gosu::GLTexInfo> Gosu::TexChunk::glTexInfo() const
+{
+    Gosu::GLTexInfo info;
+    info.texName = texName();
+    getCoords(info.left, info.top, info.right, info.bottom);
+    return info;
+}

data/GosuImpl/Graphics/TexChunk.hpp

@@ -0,0 +1,40 @@
+#ifndef GOSUIMPL_GRAPHICS_TEXCHUNK_HPP
+#define GOSUIMPL_GRAPHICS_TEXCHUNK_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/ImageData.hpp>
+#include <GosuImpl/Graphics/Common.hpp>
+#include <memory>
+#include <vector>
+#include <stdexcept>
+#include <boost/shared_ptr.hpp>
+
+class Gosu::TexChunk : public Gosu::ImageData
+{
+    Graphics* graphics;
+    DrawOpQueue* queue;
+    boost::shared_ptr<Texture> texture;
+    int x, y, w, h, padding;
+
+public:
+    TexChunk(Graphics& graphics, DrawOpQueue& queue, boost::shared_ptr<Texture> texture,
+             int x, int y, int w, int h, int padding);
+    ~TexChunk();
+
+    unsigned int width() const;
+    unsigned int height() const;
+    
+    GLuint texName() const;
+    void getCoords(double& left, double& top, double& right, double& bottom) const;
+
+    void draw(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) const;
+        
+    boost::optional<GLTexInfo> glTexInfo() const;
+};
+
+#endif
+