gosu 0.7.39-x86-mingw32

data/Gosu/Directories.hpp

@@ -0,0 +1,36 @@
+//! \file Directories.hpp
+//! Access to a small set of system paths.
+
+#ifndef GOSU_DIRECTORIES_HPP
+#define GOSU_DIRECTORIES_HPP
+
+#include <string>
+
+namespace Gosu
+{
+    //! Prefix for a program's own resources.
+    //! On Windows, the executable's containing directory.
+    //! On OS X, the application's Resources subdirectory.
+    //! On Linux, the current directory.
+    std::wstring resourcePrefix();
+    
+    //! Prefix for resources of a group of programs.
+    //! On Windows, the executable's containing directory.
+    //! On OS X, the application's containing subdirectory.
+    //! On Linux, the current directory.
+    std::wstring sharedResourcePrefix();
+    
+    //! Prefix for user settings.
+    //! On Windows, the same as %APPDATA%.
+    //! On OS X, the user's Library/Preferences folder.
+    //! On Linux, the home directory plus a trailing dot for hidden files.
+    std::wstring userSettingsPrefix();
+    
+    //! Prefix for user documents, e.g. save games.
+    //! On Windows, the My Documents folder.
+    //! On OS X, the user's Documents folder.
+    //! On Linux, the home directory.
+    std::wstring userDocsPrefix();
+}
+
+#endif

data/Gosu/Font.hpp

@@ -0,0 +1,83 @@
+//! \file Font.hpp
+//! Interface of the Font class.
+
+#ifndef GOSU_FONT_HPP
+#define GOSU_FONT_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/Color.hpp>
+#include <Gosu/GraphicsBase.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/TR1.hpp>
+#include <string>
+
+namespace Gosu
+{
+    //! A font can be used to draw text on a Graphics object very flexibly.
+    //! Fonts are ideal for small texts that change regularly. For large,
+    //! static texts you should use createBitmap and turn the result into
+    //! an image.
+    class Font
+    {
+        struct Impl;
+        std::tr1::shared_ptr<Impl> pimpl;
+
+    public:
+        //! Constructs a font that can be drawn onto the graphics object.
+        //! \param fontName Name of a system font, or a filename to a TTF
+        //!        file (must contain '/', does not work on Linux).
+        //! \param fontHeight Height of the font, in pixels.
+        //! \param fontFlags Flags used to render individual characters of
+        //!        the font.
+        Font(Graphics& graphics, const std::wstring& fontName,
+            unsigned fontHeight, unsigned fontFlags = ffBold);
+        
+        //! Returns the name of the font that was used to create it.
+        std::wstring name() const;
+        
+        //! Returns the height of the font, in pixels.
+        unsigned height() const;
+        
+        //! Returns the flags used to create the font characters.
+        unsigned flags() const;
+        
+        //! Returns the width, in pixels, the given text would occupy if drawn.
+        double textWidth(const std::wstring& text, double factorX = 1) const;
+        
+        //! Draws text so the top left corner of the text is at (x; y).
+        //! \param text Formatted text without line-breaks.
+        void draw(const std::wstring& text, double x, double y, ZPos z,
+            double factorX = 1, double factorY = 1,
+            Color c = Color::WHITE, AlphaMode mode = amDefault) const;
+        
+        //! Draws text at a position relative to (x; y).
+        //! \param relX Determines where the text is drawn horizontally. If
+        //! relX is 0.0, the text will be to the right of x, if it is 1.0,
+        //! the text will be to the left of x, if it is 0.5, it will be
+        //! centered on x. Of course, all real numbers are possible values.
+        //! \param relY See relX.
+        void drawRel(const std::wstring& text, double x, double y, ZPos z,
+            double relX, double relY, double factorX = 1, double factorY = 1,
+            Color c = Color::WHITE, AlphaMode mode = amDefault) const;
+        
+        //! Maps a letter to a specific image instead of generating one using
+        //! Gosu's built-in text rendering. This can only be called once per
+        //! character, and the character must not have been drawn before.
+        //! This ensures that Fonts are still sort of immutable.
+        void setImage(wchar_t wc, unsigned fontFlags, const Gosu::Image& image);
+        //! A shortcut for mapping a character to an image regardless of fontFlags.
+        //! Later versions might apply faux italics or faux bold to it (to be decided!).
+        void setImage(wchar_t wc, const Gosu::Image& image);
+        
+        #ifndef SWIG
+        GOSU_DEPRECATED
+        #endif
+        //! DEPRECATED: Analogous to draw, but rotates the text by a given angle. Use 
+        //! a simple pushTransform to achieve the same effect.
+        void drawRot(const std::wstring& text, double x, double y, ZPos z, double angle,
+            double factorX = 1, double factorY = 1,
+            Color c = Color::WHITE, AlphaMode mode = amDefault) const;
+    };
+}
+
+#endif

data/Gosu/Fwd.hpp

@@ -0,0 +1,31 @@
+//! \file Fwd.hpp
+//! Contains declarations of all of Gosu's available classes.
+
+#ifndef GOSU_FWD_HPP
+#define GOSU_FWD_HPP
+
+//! The library's main namespace.
+namespace Gosu
+{
+    class Audio;
+    class Bitmap;
+    class Buffer;
+    class Button;
+    class Color;
+    class File;
+    class Font;
+    class Graphics;
+    class Image;
+    class ImageData;
+    class Input;
+    class Reader;
+    class Resource;
+    class Sample;
+    class Song;
+    class TextInput;
+    class Timer;
+    class Window;
+    class Writer;
+}
+
+#endif

data/Gosu/Gosu.hpp

@@ -0,0 +1,34 @@
+//! \file Gosu.hpp
+//! Umbrella header for lazy people with fast compilers, or pre-compiled headers.
+
+//! \mainpage Gosu C++ Documentation
+//!
+//! These pages serve as a reference on the C++ interface of Gosu. For a higher-level
+//! discussion of concepts and ideas behind the library, see the Wiki entries linked
+//! from the official website, http://www.libgosu.org/.
+
+#ifndef GOSU_GOSU_HPP
+#define GOSU_GOSU_HPP
+
+#include <Gosu/Audio.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Color.hpp>
+#include <Gosu/Directories.hpp>
+#include <Gosu/Font.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Image.hpp>
+#include <Gosu/ImageData.hpp>
+#include <Gosu/Input.hpp>
+#include <Gosu/Inspection.hpp>
+#include <Gosu/IO.hpp>
+#include <Gosu/Math.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/Sockets.hpp>
+#include <Gosu/Text.hpp>
+#include <Gosu/TextInput.hpp>
+#include <Gosu/Timing.hpp>
+#include <Gosu/Utility.hpp>
+#include <Gosu/Version.hpp>
+#include <Gosu/Window.hpp>
+
+#endif

data/Gosu/Graphics.hpp

@@ -0,0 +1,120 @@
+//! \file Graphics.hpp
+//! Interface of the Graphics class.
+
+#ifndef GOSU_GRAPHICS_HPP
+#define GOSU_GRAPHICS_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/Color.hpp>
+#include <Gosu/GraphicsBase.hpp>
+#include <Gosu/TR1.hpp>
+#include <memory>
+
+namespace Gosu
+{
+    //! Returns the width, in pixels, of the user's primary screen.
+    unsigned screenWidth();
+    
+    //! Returns the height, in pixels, of the user's primary screen.
+    unsigned screenHeight();
+    
+    //! Returns the maximum size of an texture that will be allocated
+    //! internally by Gosu.
+    //! Useful when extending Gosu using OpenGL.
+    unsigned const MAX_TEXTURE_SIZE = 1024;
+    
+    typedef std::tr1::array<double, 16> Transform;
+    Transform translate(double x, double y);
+    Transform rotate(double angle, double aroundX = 0, double aroundY = 0);
+    Transform scale(double factor);
+    Transform scale(double factorX, double factorY, double fromX = 0, double fromY = 0);
+    
+    //! Serves as the target of all drawing and provides primitive drawing
+    //! functionality.
+    //! Usually created internally by Gosu::Window.
+    class Graphics
+    {
+        struct Impl;
+        const std::auto_ptr<Impl> pimpl;
+
+    public:
+        Graphics(unsigned physicalWidth, unsigned physicalHeight, bool fullscreen);
+        ~Graphics();
+
+        // Undocumented until I have thought about this...
+        void setResolution(unsigned virtualWidth, unsigned virtualHeight);
+        // End of Undocumented
+        
+        unsigned width() const;
+        unsigned height() const;
+        bool fullscreen() const;
+
+        //! Prepares the graphics object for drawing. Nothing must be drawn
+        //! without calling begin.
+        bool begin(Color clearWithColor = Color::BLACK);
+        //! Every call to begin must have a matching call to end.
+        void end();
+        //! Flushes the Z queue to the screen and starts a new one.
+        //! Useful for games that are *very* composite in nature (splitscreen).
+        void flush();
+        
+        //! Finishes all pending Gosu drawing operations and executes
+        //! the following OpenGL code in a clean environment.
+        void beginGL();
+        //! Resets Gosu into its default rendering state.
+        void endGL();
+        //! (Experimental)
+        //! Schedules a custom GL functor to be executed at a certain Z level.
+        //! The functor is called in a clean GL context (as given by beginGL/endGL).
+        //! Gosu's rendering up to the Z level may not yet have been glFlush()ed.
+        //! Note: You may not call any Gosu rendering functions from within the
+        //! functor, and you must schedule it from within Window::draw's call tree.
+        void scheduleGL(const std::tr1::function<void()>& functor, ZPos z);
+        
+        //! Enables clipping to a specified rectangle.
+        void beginClipping(double x, double y, double width, double height);
+        //! Disables clipping.
+        void endClipping();
+        
+        //! Starts recording a macro. Cannot be nested.
+        void beginRecording();
+        //! Finishes building the macro and returns it as a drawable object.
+        //! The width and height affect nothing about the recording process,
+        //! the resulting macro will simply return these values when you ask
+        //! it.
+        //! Most usually, the return value is passed to Image::Image().
+        std::auto_ptr<Gosu::ImageData> endRecording(int width, int height);
+        
+        //! Pushes one transformation onto the transformation stack.
+        void pushTransform(const Transform& transform);
+        //! Pops one transformation from the transformation stack.
+        void popTransform();
+
+        //! Draws a line from one point to another (last pixel exclusive).
+        //! Note: OpenGL lines are not reliable at all and may have a missing pixel at the start
+        //! or end point. Please only use this for debugging purposes. Otherwise, use a quad or
+        //! image to simulate lines, or contribute a better drawLine to Gosu.
+        void drawLine(double x1, double y1, Color c1,
+            double x2, double y2, Color c2,
+            ZPos z, AlphaMode mode = amDefault);
+
+        void drawTriangle(double x1, double y1, Color c1,
+            double x2, double y2, Color c2,
+            double x3, double y3, Color c3,
+            ZPos z, AlphaMode mode = amDefault);
+
+        void 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 = amDefault);
+
+        //! Turns a portion of a bitmap into something that can be drawn on
+        //! this graphics object.
+        std::auto_ptr<ImageData> createImage(const Bitmap& src,
+            unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
+            unsigned borderFlags);
+    };
+}
+
+#endif

data/Gosu/GraphicsBase.hpp

@@ -0,0 +1,66 @@
+//! \file GraphicsBase.hpp
+//! Contains general typedefs and enums related to graphics.
+
+#ifndef GOSU_GRAPHICSBASE_HPP
+#define GOSU_GRAPHICSBASE_HPP
+
+#include <Gosu/Platform.hpp>
+#include <limits>
+
+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.
+        amAdd,
+        amAdditive = amAdd,
+        //! The color's channels will be multiplied with each other.
+        amMultiply
+    };
+    
+    enum FontFlags
+    {
+        ffBold         = 1,
+        ffItalic       = 2,
+        ffUnderline    = 4,
+        ffCombinations = 8
+    };
+    
+    enum TextAlign
+    {
+        taLeft,
+        taRight,
+        taCenter,
+        taJustify
+    };
+    
+    //! Flags that affect the tileability of an image.
+    enum BorderFlags
+    {
+        bfSmooth = 0,
+        bfTileableLeft = 1,
+        bfTileableTop = 2,
+        bfTileableRight = 4,
+        bfTileableBottom = 8,
+        bfTileable = bfTileableLeft | bfTileableTop | bfTileableRight | bfTileableBottom
+    };        
+    
+    #ifndef SWIG
+    // A not so useful optimization.
+    GOSU_DEPRECATED const double zImmediate = -std::numeric_limits<double>::infinity();
+    #endif
+}
+
+#endif

data/Gosu/IO.hpp

@@ -0,0 +1,259 @@
+//! \file IO.hpp
+//! Contains everything related to input and output.
+
+#ifndef GOSU_IO_HPP
+#define GOSU_IO_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <memory>
+#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
+
+    //! Utility class that points to a specific position in a resource
+    //! and offers an interface for sequential reading.
+    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;
+        }
+    };
+    
+    //! Utility class that points to a specific position in a resource
+    //! and offers an interface for sequential writing.
+    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
+    {
+        // Non-copyable
+        Resource(const Resource&);
+        Resource& operator=(const Resource&);
+
+    public:
+        Resource()
+        {
+        }
+        
+        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;
+        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);
+
+        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;
+        const std::auto_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