gosu 0.7.39-x86-mingw32

data/Gosu/Image.hpp

@@ -0,0 +1,138 @@
+//! \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/TR1.hpp>
+#include <memory>
+
+namespace Gosu
+{
+    //! Provides functionality for drawing rectangular images.
+    class Image
+    {
+        std::tr1::shared_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 tileable = 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 tileable = false);
+        
+        //! Converts the given bitmap into an image that can be drawn onto
+        //! graphics.
+        Image(Graphics& graphics, const Bitmap& source,
+            bool tileable = 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 tileable = false);
+        
+        //! Creates an Image from a user-supplied instance of the ImageData interface.
+        explicit Image(std::auto_ptr<ImageData> data);
+
+        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 = Color::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 = Color::WHITE,
+            AlphaMode mode = amDefault) const;
+
+        //! Provides access to the underlying image data object.
+        ImageData& getData() const;
+    };
+
+    //! Convenience function that splits a BMP or PNG file into an array
+    //! 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; vector<tr1::shared_ptr<Image>>
+    //! or boost::ptr_vector<Image> are good choices.
+    template<typename Container>
+    void imagesFromTiledBitmap(Graphics& graphics, const std::wstring& filename,
+        int tileWidth, int tileHeight, bool tileable, Container& appendTo)
+    {
+        Bitmap bmp;
+        loadImageFile(bmp, filename);
+        imagesFromTiledBitmap(graphics, bmp, tileWidth, tileHeight, tileable, appendTo);
+    }
+
+    //! Convenience function that splits a bitmap into an area of array 
+    //! 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<std::tr1::shared_ptr<Image>>
+    //! or boost::ptr_vector<Image> are good choices.
+    template<typename Container>
+    void imagesFromTiledBitmap(Graphics& graphics, const Bitmap& bmp,
+        int tileWidth, int tileHeight, bool tileable, 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,
+                    tileable)));
+    }
+}
+
+#endif

data/Gosu/ImageData.hpp

@@ -0,0 +1,58 @@
+//! \file ImageData.hpp
+//! Interface of the ImageData class.
+
+#ifndef GOSU_IMAGEDATA_HPP
+#define GOSU_IMAGEDATA_HPP
+
+#include <Gosu/Color.hpp>
+#include <Gosu/GraphicsBase.hpp>
+
+namespace Gosu
+{
+    //! Contains information about the underlying OpenGL texture and the
+    //! u/v space used for image data. Can be retrieved from some images
+    //! to use them in OpenGL operations.
+    struct GLTexInfo
+    {
+        int texName;
+        float 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
+    {
+        // Non-copyable
+        ImageData(const ImageData&);
+        ImageData& operator=(const ImageData&);
+        
+    public:
+        ImageData()
+        {
+        }
+        
+        virtual ~ImageData()
+        {
+        }
+
+        virtual int width() const = 0;
+        virtual int 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 const GLTexInfo* glTexInfo() const = 0;
+        virtual Bitmap toBitmap() const = 0;
+        
+        //! Experimental and undocumented for now.
+        virtual void insert(const Bitmap& bitmap, int x, int y) = 0;
+    };
+}
+
+#endif

data/Gosu/Input.hpp

@@ -0,0 +1,161 @@
+//! \file Input.hpp
+//! Interface of the Input class.
+
+#ifndef GOSU_INPUT_HPP
+#define GOSU_INPUT_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/Platform.hpp>
+
+#ifdef GOSU_IS_WIN
+#include <Gosu/ButtonsWin.hpp>
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#endif
+
+#ifdef GOSU_IS_MAC
+#include <Gosu/ButtonsMac.hpp>
+#endif
+
+#ifdef GOSU_IS_X
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/keysym.h>
+#include <Gosu/ButtonsX.hpp>
+#endif
+
+#include <Gosu/Platform.hpp>
+#include <Gosu/Fwd.hpp>
+#include <Gosu/TR1.hpp>
+#include <vector>
+
+namespace Gosu
+{
+    //! Very lightweight class that identifies a button (keyboard, mouse or other device).
+    class Button
+    {
+        unsigned id_;
+        
+    public:
+        //! For internal use.
+        explicit Button(unsigned id) : id_(id) {}
+        //! For internal use.
+        unsigned id() const { return id_; }
+
+        //! Default constructor; == noButton.
+        Button() : id_(noButton) {}
+
+        //! Conversion from ButtonName constants.
+        Button(ButtonName name) : id_(name) {}
+    };
+    
+    //! Tests whether two Buttons identify the same physical button.
+    inline bool operator==(Button lhs, Button rhs)
+    {
+        return lhs.id() == rhs.id();
+    }
+    inline bool operator!=(Button lhs, Button rhs)
+    {
+        return !(lhs == rhs);
+    }
+    inline bool operator<(Button lhs, Button rhs)
+    {
+        return lhs.id() < rhs.id();
+    }
+    
+    //! Struct that saves information about a touch on the surface of a multi-
+    //! touch device.
+    //! Available even on non-iPhone platforms to make it easier to compile the
+    //! same source for multiple platforms.
+    struct Touch
+    {
+        //! Allows for identification of a touch across calls.
+        void* id;
+        //! Position of a touch on the touch screen.
+        float x, y;
+    };
+    typedef std::vector<Touch> Touches;
+    
+    //! Manages initialization and shutdown of the input system. Only one Input
+    //! instance can exist per application.
+    class Input
+    {
+        struct Impl;
+        const std::auto_ptr<Impl> pimpl;
+
+    public:
+        #ifdef GOSU_IS_WIN
+        Input(HWND window);
+        #endif
+        
+        #ifdef GOSU_IS_MAC
+        #ifdef GOSU_IS_IPHONE
+        Input(void* view, float updateInterval);
+        void feedTouchEvent(int type, void* touches);
+        #else
+        Input(void* window);
+        bool feedNSEvent(void* event);
+        #endif
+        #endif
+        
+        #ifdef GOSU_IS_X
+        Input(::Display* display, ::Window window);
+        bool feedXEvent(::XEvent& event);
+        #endif
+        
+        ~Input();
+        
+        //! Returns the character a button usually produces, or 0.
+        static wchar_t idToChar(Button btn);
+        //! Returns the button that has to be pressed to produce the
+        //! given character, or noButton.
+        static Button charToId(wchar_t ch);
+        
+        //! Returns true if a button is currently pressed.
+        //! Updated every tick.
+        bool down(Button btn) const;
+        
+        //! Returns the horizontal position of the mouse relative to the top
+        //! left corner of the window given to Input's constructor.
+        double mouseX() const;
+        //! See mouseX.
+        double mouseY() const;
+        
+        //! Immediately moves the mouse as far towards the desired position
+        //! as possible. x and y are relativ to the window just as in the mouse
+        //! position accessors.
+        void setMousePosition(double x, double y);
+
+        // Undocumented for the moment. Also applies to currentTouches().
+        void setMouseFactors(double factorX, double factorY);
+        
+        //! Currently known touches.
+        const Touches& currentTouches() const;
+        
+        //! Accelerometer positions in all three dimensions (smoothened).
+        double accelerometerX() const;
+        double accelerometerY() const;
+        double accelerometerZ() const;
+        
+        //! Collects new information about which buttons are pressed, where the
+        //! mouse is and calls onButtonUp/onButtonDown, if assigned.
+        void update();
+        
+        //! Assignable events that are called by update. You can bind these to your own functions.
+        //! If you use the Window class, it will assign forward these to its own methods.
+        std::tr1::function<void (Button)> onButtonDown, onButtonUp;
+        
+        //! Assignable events that are called by update. You can bind these to your own functions.
+        //! If you use the Window class, it will assign forward these to its own methods.
+        std::tr1::function<void (Touch)> onTouchBegan, onTouchMoved, onTouchEnded;
+        
+        //! Returns the currently active TextInput instance, or 0.
+        TextInput* textInput() const;
+        //! Sets the currently active TextInput, or clears it (input = 0).
+        void setTextInput(TextInput* input);
+    };
+}
+
+#endif

data/Gosu/Inspection.hpp

@@ -0,0 +1,14 @@
+//! \file Inspection.hpp
+//! A special set of functions designed for tuning Gosu games.
+
+#ifndef GOSU_INSPECTION_HPP
+#define GOSU_INSPECTION_HPP
+
+namespace Gosu
+{
+    //! Returns the current framerate, as determined by an unspecified and possibly
+    //! horrible algorithm.
+    int fps();
+}
+
+#endif

data/Gosu/Math.hpp

@@ -0,0 +1,135 @@
+//! \file Math.hpp
+//! Contains simple math functionality.
+
+#ifndef GOSU_MATH_HPP
+#define GOSU_MATH_HPP
+
+namespace Gosu
+{
+    //! Pi.
+    const double pi = 3.1415926536;
+    
+    //! Truncates the fractional part of a real value. Equivalent to
+    //! static_cast<long>.
+    inline long trunc(double value)
+    {
+        return static_cast<long>(value);
+    }
+    
+    //! Rounds a real value towards the next integer.
+    inline long round(double value)
+    {
+        if (value >= 0)
+            return static_cast<long>(value + 0.5);
+        else
+            return static_cast<long>(value - 0.5);
+    }
+    
+    //! Returns a real value between min (inclusive) and max (exclusive).
+    //! Uses std::rand, so you should call std::srand before using it.
+    double random(double min, double max);
+    
+    //! Translates between Gosu's angle system (where 0� is at the top)
+    //! and radians (where 0 is at the right).
+    inline double gosuToRadians(double angle)
+    {
+        return (angle - 90) * pi / 180;
+    }
+    //! Translates between Gosu's angle system (where 0� is at the top)
+    //! and radians (where 0 is at the right).
+    inline double radiansToGosu(double angle)
+    {
+        return angle * 180 / pi + 90;
+    }
+
+    //! Translates between degrees (used by Gosu) and radians, i.e. it
+    //! does not change the 'origin' of the angle system.
+    inline double degreesToRadians(double angle)
+    {
+        return angle * pi / 180;
+    }
+    //! Translates between degrees (used by Gosu) and radians, i.e. it
+    //! does not change the 'origin' of the angle system.
+    inline double radiansToDegrees(double angle)
+    {
+        return angle * 180 / pi;
+    }
+    
+    //! Returns the horizontal distance between the origin and the point to
+    //! which you would get if you moved radius pixels in the direction
+    //! specified by angle.
+    //! \param angle Angle in degrees where 0.0 means upwards.
+    double offsetX(double angle, double radius);
+    //! Returns the vertical distance between the origin and the point to
+    //! which you would get if you moved radius pixels in the direction
+    //! specified by angle.
+    //! \param angle Angle in degrees where 0.0 means upwards.
+    double offsetY(double angle, double radius);
+    //! Returns the angle from point 1 to point 2 in degrees, where 0.0 means
+    //! upwards. Returns def if both points are equal.
+    double angle(double fromX, double fromY, double toX, double toY,
+        double def = 0);
+    //! Returns the smallest angle that can be added to angle1 to get to
+    //! angle2 (can be negative if counter-clockwise movement is shorter).
+    double angleDiff(double angle1, double angle2);
+    //! Normalizes an angle to fit into the range [0; 360[.
+    double normalizeAngle(double angle);
+    
+    //! Returns value * value.
+    template<typename T>
+    T square(T value)
+    {
+        return value * value;
+    }
+    
+    //! Returns min if value is smaller than min, max if value is larger than
+    //! max and value otherwise.
+    template<typename T>
+    T clamp(T value, T min, T max)
+    {
+        if (value < min)
+            return min;
+        if (value > max)
+            return max;
+        return value;
+    }
+    
+    // Backward compatibility with 0.7.x
+    template<typename T>
+    T boundBy(T value, T min, T max)
+    {
+        return clamp(value, min, max);
+    }
+    
+    //! Returns (value-min) % (max-min) + min, where % always has a positive
+    //! result for max > min. The results are undefined for max <= min.
+    //! Note: This means that max is exclusive.
+    int wrap(int value, int min, int max);
+    //! Returns (value-min) % (max-min) + min, where % always has a positive
+    //! result for max > min. The results are undefined for max <= min.
+    //! Note: This means that max is exclusive.
+    float wrap(float value, float min, float max);
+    //! Returns (value-min) % (max-min) + min, where % always has a positive
+    //! result for max > min. The results are undefined for max <= min.
+    //! Note: This means that max is exclusive.
+    double wrap(double value, double min, double max);
+    
+    //! Returns the square of the distance between two points.
+    inline double distanceSqr(double x1, double y1, double x2, double y2)
+    {
+        return square(x1 - x2) + square(y1 - y2);
+    }
+    
+    //! Returns the distance between two points.
+    double distance(double x1, double y1, double x2, double y2);
+    
+    //! Interpolates a value between a and b, weight being the bias towards the second value.
+    //! Examples: interpolate(0, 10, 0.5) == 5, interpolate(-10, 10, 0.25) == 5, interpolate(0, 10, -0.5) == -5.
+    template<typename T>
+    T interpolate(T a, T b, double weight = 0.5)
+    {
+        return a * (1.0 - weight) + b * weight;
+    }
+}
+
+#endif