gosu 0.7.10.1

data/Gosu/ButtonsX.hpp

@@ -0,0 +1,115 @@
+#ifndef GOSU_BUTTONSX_HPP
+#define GOSU_BUTTONSX_HPP
+
+namespace Gosu
+{
+    //! Enumerates all the named button ids that can be used with Gosu::Input.
+    //! This enumeration contains ids for non-character keyboard keys (kb*),
+    //! mouse buttons and mouse wheel (ms*) and gamepad buttons (gp*).
+    enum ButtonName
+    {
+        kbRangeBegin = 0x01,
+        kbEscape = XK_Escape,
+        kbF1 = XK_F1,
+        kbF2 = XK_F2,
+        kbF3 = XK_F3,
+        kbF4 = XK_F4,
+        kbF5 = XK_F5,
+        kbF6 = XK_F6,
+        kbF7 = XK_F7,
+        kbF8 = XK_F8,
+        kbF9 = XK_F9,
+        kbF10 = XK_F10,
+        kbF11 = XK_F11,
+        kbF12 = XK_F12,
+        kb1 = XK_1,
+        kb2 = XK_2,
+        kb3 = XK_3,
+        kb4 = XK_4,
+        kb5 = XK_5,
+        kb6 = XK_6,
+        kb7 = XK_7,
+        kb8 = XK_8,
+        kb9 = XK_9,
+        kb0 = XK_0,
+        kbTab = XK_Tab,
+        kbReturn = XK_Return,
+        kbSpace = XK_space,
+        kbLeftShift = XK_Shift_L,
+        kbRightShift = XK_Shift_R,
+        kbLeftControl = XK_Control_L,
+        kbRightControl = XK_Control_R,
+        kbLeftAlt = XK_Alt_L,
+        kbRightAlt = XK_Alt_R,
+        kbLeftMeta = 0, // TODO?!
+        kbRightMeta = 0,
+        kbBackspace = XK_BackSpace,
+        kbLeft = XK_Left,
+        kbRight = XK_Right,
+        kbUp = XK_Up,
+        kbDown = XK_Down,
+        kbHome = XK_Home,
+        kbEnd = XK_End,
+        kbInsert = XK_Insert,
+        kbDelete = XK_Delete,
+        kbPageUp = XK_Prior,
+        kbPageDown = XK_Next,
+        kbEnter = XK_KP_Enter,
+        kbNumpad1 = XK_KP_1,
+        kbNumpad2 = XK_KP_2,
+        kbNumpad3 = XK_KP_3,
+        kbNumpad4 = XK_KP_4,
+        kbNumpad5 = XK_KP_5,
+        kbNumpad6 = XK_KP_6,
+        kbNumpad7 = XK_KP_7,
+        kbNumpad8 = XK_KP_8,
+        kbNumpad9 = XK_KP_9,
+        kbNumpad0 = XK_KP_0,
+        kbNumpadAdd = XK_KP_Add,
+        kbNumpadSubtract = XK_KP_Subtract,
+        kbNumpadMultiply = XK_KP_Multiply,
+        kbNumpadDivide = XK_KP_Divide,
+        kbRangeEnd = 0xffff,
+        
+        msRangeBegin,
+        msLeft = msRangeBegin,
+        msRight,
+        msMiddle,
+        msWheelUp,
+        msWheelDown,
+        msRangeEnd,
+        
+        gpRangeBegin,
+        gpLeft = gpRangeBegin,
+        gpRight,
+        gpUp,
+        gpDown,
+        gpButton0,
+        gpButton1,
+        gpButton2,
+        gpButton3,
+        gpButton4,
+        gpButton5,
+        gpButton6,
+        gpButton7,
+        gpButton8,
+        gpButton9,
+        gpButton10,
+        gpButton11,
+        gpButton12,
+        gpButton13,
+        gpButton14,
+        gpButton15,
+        gpRangeEnd = gpButton15,
+        
+        kbNum = kbRangeEnd - kbRangeBegin + 1,
+        msNum = msRangeEnd - msRangeBegin + 1,
+        gpNum = gpRangeEnd - gpRangeBegin + 1,
+        
+        numButtons = gpRangeEnd,
+		noButton = 0xffffffff
+    };
+}
+
+#endif
+

data/Gosu/Color.hpp

@@ -0,0 +1,172 @@
+//! \file Color.hpp
+//! Interface of the Color class.
+
+#ifndef GOSU_COLOR_HPP
+#define GOSU_COLOR_HPP
+
+#include <boost/cstdint.hpp>
+
+namespace Gosu
+{
+    //! Represents an ARGB color value with 8 bits for each channel. Can be
+    //! implicitly constructed from literals of the form 0xaarrggbb. Has fast
+    //! value semantics.
+    class Color
+    {
+        boost::uint32_t rep;
+
+    public:
+        typedef boost::uint8_t Channel;
+
+        //! The default constructor does not initialize the color to any value.
+        Color()
+        {
+        }
+
+        //! Conversion constructor for literals of the form 0xaarrggbb.
+        //! (C++ only.)
+        Color(boost::uint32_t argb)
+        : rep(argb)
+        {
+        }
+
+        Color(Channel red, Channel green, Channel blue)
+        {
+            rep = (0xff << 24) | (red << 16) | (green << 8) | blue;
+        }
+
+        Color(Channel alpha, Channel red, Channel green, Channel blue)
+        {
+            rep = (alpha << 24) | (red << 16) | (green << 8) | blue;
+        }
+        
+        //! Constructs a color from the given hue/saturation/value triple.
+        //! Ranges of these values are given as 0..360, 0..1 and 0..1,
+        //! respectively.
+        //! The alpha value is set to 1 from this method.
+        static Color fromHSV(double h, double s, double v);
+        static Color fromAHSV(Channel alpha, double h, double s, double v);
+
+        Channel alpha() const
+        {
+            return static_cast<Channel>((rep >> 24) & 0xff);
+        }
+
+        Channel red() const
+        {
+            return static_cast<Channel>((rep >> 16) & 0xff);
+        }
+
+        Channel green() const
+        {
+            return static_cast<Channel>((rep >> 8) & 0xff);
+        }
+
+        Channel blue() const
+        {
+            return static_cast<Channel>(rep & 0xff);
+        }
+
+        void setAlpha(Channel value)
+        {
+            rep &= 0x00ffffff;
+            rep |= value << 24;
+        }
+
+        void setRed(Channel value)
+        {
+            rep &= 0xff00ffff;
+            rep |= value << 16;
+        }
+
+        void setGreen(Channel value)
+        {
+            rep &= 0xffff00ff;
+            rep |= value << 8;
+        }
+
+        void setBlue(Channel value)
+        {
+            rep &= 0xffffff00;
+            rep |= value;
+        }
+
+        //! Returns the hue of the color, in the usual range of 0..360.
+        double hue() const;
+        
+        //! Changes the current color so hue() will return h.
+        void setHue(double h);
+        
+        //! Returns the saturation of the color, in the range of 0..1.
+        double saturation() const;
+        
+        //! Changes the current color so saturation() will return s.
+        void setSaturation(double s);
+        
+        //! Returns the value (brightness) of the color, in the range of 0..1.
+        double value() const;
+        
+        //! Changes the current color so value() will return v.
+        void setValue(double v);
+
+        //! Returns the color in 0xaarrggbb representation.
+        boost::uint32_t argb() const
+        {
+            return rep;
+        }
+
+        //! Returns the color in 0x00bbggrr representation.
+        boost::uint32_t bgr() const
+        {
+            return red() | (rep & 0x0000ff00) | blue() << 16;
+        }
+
+        //! Returns the color in 0xaabbggrr representation.
+        boost::uint32_t abgr() const
+        {
+            return alpha() << 24 | bgr();
+        }
+    };
+    
+    // Causes weird errors when included in the SWIG wrapping process.
+    // If, with a future version of SWIG, this can be included and
+    // require 'gosu'; include Gosu
+    // works from within Ruby, the #ifndef guard can be removed.
+    #ifndef SWIG
+    inline bool operator==(Color a, Color b)
+    {
+        return a.argb() == b.argb();
+    }
+
+    inline bool operator!=(Color a, Color b)
+    {
+        return a.argb() != b.argb();
+    }
+    #endif
+
+    //! Interpolates linearly between two colors, with a given weight towards
+    //! the second color.
+    //! Specialization of the general function in Gosu/Math.hpp.
+    Color interpolate(Color a, Color b, double weight = 0.5);
+    
+    //! Combines two colors as if their channels were mapped to the 0..1 range
+    //! and then multiplied with each other.
+    Color multiply(Color a, Color b);
+
+    //! Namespace which contains some predefined colors.
+    namespace Colors
+    {
+        const Color none    = 0x00000000;
+        const Color black   = 0xff000000;
+        const Color gray    = 0xff808080;
+        const Color white   = 0xffffffff;
+        const Color red     = 0xffff0000;
+        const Color green   = 0xff00ff00;
+        const Color blue    = 0xff0000ff;
+        const Color yellow  = 0xffffff00;
+        const Color fuchsia = 0xffff00ff;
+        const Color cyan    = 0xff00ffff;
+    }
+}
+
+#endif

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,59 @@
+//! \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 <boost/scoped_ptr.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;
+        boost::scoped_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 '/').
+        //! \param height Height of the font, in pixels.
+        Font(Graphics& graphics, const std::wstring& fontName,
+            unsigned height);
+        ~Font();
+
+        //! Returns the height of the font, in pixels.
+        unsigned height() const;
+
+        //! Returns the width 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).
+        void draw(const std::wstring& text, double x, double y, ZPos z,
+            double factorX = 1, double factorY = 1,
+            Color c = Colors::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 = Colors::white, AlphaMode mode = amDefault) const;
+            
+        void drawRot(const std::wstring& text, double x, double y, ZPos z, double angle,
+            double factorX = 1, double factorY = 1,
+            Color c = Colors::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 Color;
+    class File;
+    class Font;
+    class Graphics;
+    class Image;
+    class ImageData;
+    class Input;
+    class Reader;
+    class Resource;
+    class RotFlip;
+    class Sample;
+    class Song;
+    class TextInput;
+    class Timer;
+    class Window;
+    class Writer;
+}
+
+#endif

data/Gosu/Gosu.hpp

@@ -0,0 +1,26 @@
+//! \file Gosu.hpp
+//! Umbrella header for lazy people with fast compilers, or pre-compiled headers.
+
+#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/IO.hpp>
+#include <Gosu/Math.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/RotFlip.hpp>
+#include <Gosu/Sockets.hpp>
+#include <Gosu/Text.hpp>
+#include <Gosu/TextInput.hpp>
+#include <Gosu/Timing.hpp>
+#include <Gosu/Window.hpp>
+
+#endif

data/Gosu/Graphics.hpp

@@ -0,0 +1,86 @@
+//! \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 <boost/scoped_ptr.hpp>
+#include <memory>
+
+namespace Gosu
+{
+    //! Flags that affect the softness of a border.
+    enum BorderFlags
+    {
+        bfSoft = 0,
+        bfHardLeft = 1,
+        bfHardTop = 2,
+        bfHardRight = 4,
+        bfHardBottom = 8,
+        bfHard = bfHardLeft | bfHardTop | bfHardRight | bfHardBottom
+    };        
+    
+    //! Serves as the target of all drawing and provides basic drawing
+    //! functionality.
+    //! Usually created by Gosu::Window.
+    class Graphics
+    {
+        struct Impl;
+        boost::scoped_ptr<Impl> pimpl;
+
+    public:
+        Graphics(unsigned physicalWidth, unsigned physicalHeight, bool fullscreen);
+        ~Graphics();
+
+        // Undocumented until I have thought about this...
+        double factorX() const;
+        double factorY() const;
+        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 = Colors::black);
+        //! Every call to begin must have a matching call to end.
+        void end();
+        //! 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();
+        // Enables clipping to a specified rectangle.
+        void beginClipping(int x, int y, unsigned width, unsigned height);
+        // Disables clipping.
+        void endClipping();
+
+        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