gosu 0.7.10.1

data/Gosu/GraphicsBase.hpp

@@ -0,0 +1,45 @@
+//! \file GraphicsBase.hpp
+//! Contains general typedefs and enums related to graphics.
+
+#ifndef GOSU_GRAPHICSBASE_HPP
+#define GOSU_GRAPHICSBASE_HPP
+
+#include <boost/cstdint.hpp>
+
+namespace Gosu
+{
+    //! Represents the Z position of something drawn with Gosu's graphics
+    //! system. Draw calls with higher ZPos values will cover those with a
+    //! lower ZPos value, that is, they are performed last.
+    typedef double ZPos;
+
+    //! Determines the way colors are combined when one is drawn onto
+    //! another.
+    enum AlphaMode
+    {
+        //! The color's channels will be interpolated. The alpha channel
+        //! specifies the opacity of the new color, 255 is full opacity.
+        amDefault,
+        //! The colors' channels will be added. The alpha channel specifies
+        //! the percentage of the new color's channels that will be added
+        //! to the old color's channels.
+        amAdditive
+    };
+
+    enum FontFlags
+    {
+        ffBold      = 1,
+        ffItalic    = 2,
+        ffUnderline = 4
+    };
+
+    enum TextAlign
+    {
+        taLeft,
+        taRight,
+        taCenter,
+        taJustify
+    };
+}
+
+#endif

data/Gosu/IO.hpp

@@ -0,0 +1,255 @@
+//! \file IO.hpp
+//! Contains everything related to input and output.
+
+#ifndef GOSU_IO_HPP
+#define GOSU_IO_HPP
+
+#include <boost/utility.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <cstddef>
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace Gosu
+{
+    class Resource;
+    
+    enum ByteOrder { boLittle, boBig, boDontCare };
+#ifdef __BIG_ENDIAN__
+    const ByteOrder nativeByteOrder = boBig, otherByteOrder = boLittle;
+#else
+    const ByteOrder nativeByteOrder = boLittle, otherByteOrder = boBig;
+#endif
+
+    class Reader
+    {
+        const Resource* res;
+        std::size_t pos;
+
+    public:
+        Reader(const Resource& resource, std::size_t position)
+        : res(&resource), pos(position)
+        {
+        }
+
+        const Resource& resource() const
+        {
+            return *res;
+        }
+
+        std::size_t position() const
+        {
+            return pos;
+        }
+
+        void setPosition(std::size_t value)
+        {
+            // TODO: Check?
+            pos = value;
+        }
+
+        void seek(std::ptrdiff_t offset)
+        {
+            // TODO: Check?
+            pos += offset;
+        }
+
+        void read(void* destBuffer, std::size_t length);
+        
+        //! Convenience function; equivalent to read(&t, sizeof t).
+        template<typename T>
+        void readPod(T& t, ByteOrder bo = boDontCare)
+        {
+            read(&t, sizeof t);
+            if (bo == otherByteOrder)
+            {
+                char* begin = reinterpret_cast<char*>(&t);
+                std::reverse(begin, begin + sizeof t);
+            }
+        }
+
+        //! Similar to readPod(T&), but returns the read value instead.
+        template<typename T>
+        T getPod(ByteOrder bo = boDontCare)
+        {
+            T t;
+            readPod<T>(t, bo);
+            return t;
+        }
+    };
+
+    class Writer
+    {
+        Resource* res;
+        std::size_t pos;
+
+    public:
+        Writer(Resource& resource, std::size_t position)
+        : res(&resource), pos(position)
+        {
+        }
+
+        Resource& resource() const
+        {
+            return *res;
+        }
+
+        std::size_t position() const
+        {
+            return pos;
+        }
+
+        void setPosition(std::size_t value)
+        {
+            // TODO: Check?
+            pos = value;
+        }
+
+        void seek(std::ptrdiff_t offset)
+        {
+            // TODO: Check?
+            pos += offset;
+        }
+
+        void write(const void* sourceBuffer, std::size_t length);
+
+        //! Convenience function; equivalent to write(&t, sizeof t).
+        template<typename T>
+        void writePod(const T& t, ByteOrder bo = boDontCare)
+        {
+            if (bo == otherByteOrder)
+            {
+                char buf[sizeof t];
+                const char* begin = reinterpret_cast<const char*>(&t);
+                std::reverse_copy(begin, begin + sizeof t, buf);
+                write(buf, sizeof buf);
+            }
+            else
+                write(&t, sizeof t);
+        }
+    };
+
+    //! Base class for resources. A resource in Gosu is nothing more but a
+    //! piece of binary data that can be read or written, for example files
+    //! or simply areas of allocated memory.
+    //! A resource always knows its size and can resize itself, thereby either
+    //! truncating its content or allocating room for more data.
+    class Resource : boost::noncopyable
+    {
+    public:
+        virtual ~Resource()
+        {
+        }
+
+        //! Convenience: Creates a new Reader that reads from the start of
+        //! the resource.
+        Reader frontReader() const
+        {
+            return Reader(*this, 0);
+        }
+
+        //! Convenience: Creates a new Writer that appends data at the
+        //! end of the resource.
+        Writer backWriter()
+        {
+            return Writer(*this, size());
+        }
+
+        virtual std::size_t size() const = 0;
+
+        virtual void resize(std::size_t newSize) = 0;
+
+        virtual void read(std::size_t offset, std::size_t length,
+            void* destBuffer) const = 0;
+
+        virtual void write(std::size_t offset, std::size_t length,
+            const void* sourceBuffer) = 0;
+    };
+
+    //! Piece of memory with the Resource interface.
+    class Buffer : public Resource
+    {
+        std::vector<char> buf;
+
+    public:
+        Buffer()
+        {
+        }
+
+        Buffer(const Buffer& other)
+        : buf(other.buf)
+        {
+        }
+
+        Buffer& operator=(const Buffer& other)
+        {
+            buf = other.buf;
+            return *this;
+        }
+
+        std::size_t size() const
+        {
+            return buf.size();
+        }
+
+        void resize(std::size_t newSize)
+        {
+            buf.resize(newSize);
+        }
+
+        void read(std::size_t offset, std::size_t length,
+            void* destBuffer) const;
+
+        void write(std::size_t offset, std::size_t length,
+            const void* sourceBuffer);
+
+        const void* data() const
+        {
+            return &buf[0];
+        }
+
+        void* data()
+        {
+            return &buf[0];
+        }
+    };
+
+    enum FileMode
+    {
+        //! Opens an existing file for reading; throws an exception if the file
+        //! cannot be found.
+        fmRead,
+        //! Writes data to a file. If the file already exists, is emptied on
+        //! opening. If the file does not exist, it is created.
+        fmReplace,
+        //! Opens or creates a file with writing access, but does not clear
+        //! existing contents.
+        fmAlter
+    };
+
+    //! File with the Resource interface.
+    class File : public Resource
+    {
+        struct Impl;
+        boost::scoped_ptr<Impl> pimpl;
+
+    public:
+        explicit File(const std::wstring& filename, FileMode mode = fmRead);
+        ~File();
+
+        std::size_t size() const;
+        void resize(std::size_t newSize);
+        void read(std::size_t offset, std::size_t length,
+            void* destBuffer) const;
+        void write(std::size_t offset, std::size_t length,
+            const void* sourceBuffer);
+    };
+
+    //! Loads a whole file into a buffer.
+    void loadFile(Buffer& buffer, const std::wstring& filename);
+    //! Creates or overwrites a file with the contents of a buffer.
+    void saveFile(const Buffer& buffer, const std::wstring& filename);
+}
+
+#endif

data/Gosu/Image.hpp

@@ -0,0 +1,148 @@
+//! \file Image.hpp
+//! Interface of the Image class and helper functions.
+
+#ifndef GOSU_IMAGE_HPP
+#define GOSU_IMAGE_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/RotFlip.hpp>
+#include <boost/scoped_ptr.hpp>
+
+namespace Gosu
+{
+    //! Provides functionality for drawing rectangular images.
+    class Image
+    {
+        boost::scoped_ptr<ImageData> data;
+
+    public:
+        //! Loads an image from a given filename that can be drawn onto
+        //! graphics.
+		//! This constructor can handle PNG and BMP images. A color key of #ff00ff is
+		//! automatically applied to BMP type images. For more flexibility, use the
+		//! corresponding constructor that uses a Bitmap object.
+        Image(Graphics& graphics, const std::wstring& filename,
+              bool hardBorders = false);
+        //! Loads a portion of the the image at the given filename that can be
+        //! drawn onto graphics.
+		//! This constructor can handle PNG and BMP images. A color key of #ff00ff is
+		//! automatically applied to BMP type images. For more flexibility, use the
+		//! corresponding constructor that uses a Bitmap object.
+        Image(Graphics& graphics, const std::wstring& filename, unsigned srcX,
+              unsigned srcY, unsigned srcWidth, unsigned srcHeight,
+              bool hardBorders = false);
+        
+        //! Converts the given bitmap into an image that can be drawn onto
+        //! graphics.
+        Image(Graphics& graphics, const Bitmap& source,
+            bool hardBorders = false);
+        //! Converts a portion of the given bitmap into an image that can be
+        //! drawn onto graphics.
+        Image(Graphics& graphics, const Bitmap& source, unsigned srcX,
+            unsigned srcY, unsigned srcWidth, unsigned srcHeight,
+            bool hardBorders = false);
+
+        ~Image();
+
+        unsigned width() const;
+        unsigned height() const;
+
+        //! Draws the image so its upper left corner is at (x; y).
+        void draw(double x, double y, ZPos z,
+            double factorX = 1, double factorY = 1,
+            Color c = Colors::white,
+            AlphaMode mode = amDefault) const;
+        //! Like draw(), but allows to give modulation colors for all four
+        //! corners.
+        void drawMod(double x, double y, ZPos z,
+            double factorX, double factorY,
+            Color c1, Color c2, Color c3, Color c4,
+            AlphaMode mode = amDefault) const;
+
+        //! Draws the image rotated by the given angle so that its rotation
+        //! center is at (x; y). Note that this is different from how all the
+        //! other drawing functions work!
+        //! \param angle See Math.hpp for an explanation of how Gosu interprets
+        //! angles.
+        //! \param centerX Relative horizontal position of the rotation center
+        //! on the image. 0 is the left border, 1 is the right border, 0.5 is
+        //! the center (and default).
+        //! \param centerY See centerX.
+        void drawRot(double x, double y, ZPos z,
+            double angle, double centerX = 0.5, double centerY = 0.5,
+            double factorX = 1, double factorY = 1,
+            Color c = Colors::white,
+            AlphaMode mode = amDefault) const;
+
+        #ifndef SWIG
+        void drawRotFlip(double x, double y, ZPos z,
+            RotFlip rf,
+            double factorX = 1, double factorY = 1,
+            Color c = Colors::white,
+            AlphaMode mode = amDefault) const;
+        void drawRotFlipMod(double x, double y, ZPos z,
+            RotFlip rf,
+            double factorX, double factorY,
+            Color c1, Color c2, Color c3, Color c4,
+            AlphaMode mode = amDefault) const;
+
+        //! Provides access to the underlying image data object.
+        const ImageData& getData() const;
+        #endif
+    };
+
+	//! Convenience function that splits a BMP or PNG file into an area
+	//! of small rectangles and creates images from them.
+    //! \param tileWidth If positive, specifies the width of one tile in
+    //! pixels. If negative, the bitmap is divided into -tileWidth rows.
+    //! \param tileHeight See tileWidth.
+    //! \param appendTo STL container to which the images will be appended.
+    //! Must provide a push_back member function; std::vector<boost::shared_ptr<Image>>
+    //! is usually the most reasonable container.
+    template<typename Container>
+    void imagesFromTiledBitmap(Graphics& graphics, const std::wstring& filename,
+        int tileWidth, int tileHeight, bool hardBorders, Container& appendTo)
+    {
+		imagesFromTiledBitmap(graphics, quickLoadBitmap(filename), tileWidth, tileHeight, hardBorders, appendTo);
+    }
+
+    //! Convenience function that splits a bitmap into an area of small 
+    //! rectangles and creates images from them.
+    //! \param tileWidth If positive, specifies the width of one tile in
+    //! pixels. If negative, the bitmap is divided into -tileWidth rows.
+    //! \param tileHeight See tileWidth.
+    //! \param appendTo STL container to which the images will be appended.
+    //! Must provide a push_back member function; std::vector<boost::shared_ptr<Image>>
+    //! is usually the most reasonable container.
+    template<typename Container>
+    void imagesFromTiledBitmap(Graphics& graphics, const Bitmap& bmp,
+        int tileWidth, int tileHeight, bool hardBorders, Container& appendTo)
+    {
+        int tilesX, tilesY;
+
+        if (tileWidth > 0)
+            tilesX = bmp.width() / tileWidth;
+        else
+        {
+            tilesX = -tileWidth;
+            tileWidth = bmp.width() / tilesX;
+        }
+        
+        if (tileHeight > 0)
+            tilesY = bmp.height() / tileHeight;
+        else
+        {
+            tilesY = -tileHeight;
+            tileHeight = bmp.height() / tilesY;
+        }
+        
+        for (int y = 0; y < tilesY; ++y)
+            for (int x = 0; x < tilesX; ++x)
+                appendTo.push_back(typename Container::value_type(new Image(graphics, bmp,
+                    x * tileWidth, y * tileHeight, tileWidth, tileHeight,
+                    hardBorders)));
+    }
+}
+
+#endif

data/Gosu/ImageData.hpp

@@ -0,0 +1,45 @@
+//! \file ImageData.hpp
+//! Interface of the ImageData class.
+
+#ifndef GOSU_IMAGEDATA_HPP
+#define GOSU_IMAGEDATA_HPP
+
+#include <Gosu/Color.hpp>
+#include <Gosu/GraphicsBase.hpp>
+#include <boost/optional.hpp>
+#include <boost/utility.hpp>
+
+namespace Gosu
+{
+    struct GLTexInfo
+    {
+        int texName;
+        double left, right, top, bottom;
+    };
+
+    //! The ImageData class is an abstract base class for drawable images.
+    //! Instances of classes derived by ImageData are usually returned by
+    //! Graphics::createImage and usually only used to implement drawing
+    //! primitives like Image, which then provide a more specialized and
+    //! intuitive drawing interface.
+    class ImageData : boost::noncopyable
+    {
+    public:
+        virtual ~ImageData()
+        {
+        }
+
+        virtual unsigned width() const = 0;
+        virtual unsigned height() const = 0;
+
+        virtual 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 = 0;
+            
+        virtual boost::optional<GLTexInfo> glTexInfo() const = 0;
+    };
+}
+
+#endif