gosu 0.8.6-x64-mingw32

data/Gosu/ImageData.hpp

@@ -0,0 +1,61 @@
+//! \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 <Gosu/Fwd.hpp>
+#include <Gosu/Platform.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;
+        
+        virtual GOSU_UNIQUE_PTR<ImageData> subimage(int x, int y, int width, int height) const = 0;
+        
+        virtual void insert(const Bitmap& bitmap, int x, int y) = 0;
+    };
+}
+
+#endif

data/Gosu/Input.hpp

@@ -0,0 +1,149 @@
+//! \file Input.hpp
+//! Interface of the Input class.
+
+#ifndef GOSU_INPUT_HPP
+#define GOSU_INPUT_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/Buttons.hpp>
+#include <Gosu/TR1.hpp>
+
+#ifdef GOSU_IS_WIN
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#endif
+
+#ifdef GOSU_IS_X
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#endif
+
+#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 GOSU_UNIQUE_PTR<Impl> pimpl;
+    #if defined(GOSU_CPP11_ENABLED)
+        // explicitly forbid copying and moving
+        Input(Input&&) = delete;
+        Input& operator=(Input&&) = delete;
+        Input(const Input&) = delete;
+        Input& operator=(const Input&) = delete;
+    #endif
+
+    public:
+    #ifdef GOSU_IS_IPHONE
+        Input(void* view, float updateInterval);
+        void feedTouchEvent(int type, void* touches);
+    #else
+        Input();
+        bool feedSDLEvent(void* 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, double offsetX = 0, double offsetY = 0);
+        
+        //! 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

data/Gosu/Platform.hpp

@@ -0,0 +1,93 @@
+//! \file Platform.hpp
+//! Macros and utility functions to facilitate programming on all of Gosu's supported platforms.
+
+#ifndef GOSU_PLATFORM_HPP
+#define GOSU_PLATFORM_HPP
+
+#ifdef __BIG_ENDIAN__
+# define GOSU_IS_BIG_ENDIAN
+# define IDENTITY_FUN bigToNative
+# define IDENTITY_FUN2 nativeToBig
+# define CONV_FUN littleToNative
+# define CONV_FUN2 nativeToLittle
+#else
+# define GOSU_IS_LITTLE_ENDIAN
+# define IDENTITY_FUN littleToNative
+# define IDENTITY_FUN2 nativeToLittle
+# define CONV_FUN bigToNative
+# define CONV_FUN2 nativeToBig
+#endif
+
+#include <algorithm>
+
+namespace Gosu
+{
+    template<typename T> T IDENTITY_FUN(T t) { return t; }
+    template<typename T> T IDENTITY_FUN2(T t) { return t; }
+    
+    template<typename T>
+    T CONV_FUN(T t)
+    {
+        char* begin = reinterpret_cast<char*>(&t);
+        std::reverse(begin, begin + sizeof t);
+        return t;
+    }
+
+    template<typename T> T CONV_FUN2(T t) { return CONV_FUN(t); }
+}
+
+#undef IDENTITY_FUN
+#undef IDENTITY_FUN2
+#undef CONV_FUN
+#undef CONV_FUN2
+
+#if defined(_MSC_VER)
+# define GOSU_NORETURN __declspec(noreturn)
+#elif defined(__GNUC__)
+# define GOSU_NORETURN __attribute__ ((noreturn))
+#endif
+
+#if defined(WIN32)
+# define GOSU_IS_WIN
+#else
+# define GOSU_IS_UNIX
+# if defined(__linux) || defined(__FreeBSD__)
+#  define GOSU_IS_X
+# else
+#  define GOSU_IS_MAC
+#  include <TargetConditionals.h>
+#  if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
+#   define GOSU_IS_IPHONE
+#  endif
+# endif
+#endif
+
+#if defined (GOSU_IS_IPHONE) || defined(__arm__)
+# define GOSU_IS_OPENGLES
+#endif
+
+#ifndef SWIG
+# if _MSC_VER >= 1700 || ((__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__GXX_EXPERIMENTAL_CXX0X__))
+#  define GOSU_CPP11_ENABLED
+# endif
+#endif
+
+#ifdef GOSU_CPP11_ENABLED
+# define GOSU_UNIQUE_PTR std::unique_ptr
+# define GOSU_MOVE_UNIQUE_PTR(ptr) std::move(ptr)
+#else
+# define GOSU_UNIQUE_PTR std::auto_ptr
+# define GOSU_MOVE_UNIQUE_PTR(ptr) (ptr)
+#endif
+
+#ifndef GOSU_DEPRECATED
+# if defined(GOSU_IS_WIN)
+#  define GOSU_DEPRECATED __declspec(deprecated)
+# elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+#  define GOSU_DEPRECATED  __attribute__((__deprecated__))
+# else
+#  define GOSU_DEPRECATED
+# endif
+#endif
+
+#endif