gosu 0.7.10.1

data/Gosu/Input.hpp

@@ -0,0 +1,116 @@
+//! \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>
+#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 <boost/function.hpp>
+#include <boost/scoped_ptr.hpp>
+
+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 getId() 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.getId() == rhs.getId();
+	}
+	inline bool operator!=(Button lhs, Button rhs)
+	{
+		return !(lhs == rhs);
+	}
+	
+    //! Manages initialization and shutdown of the input system; only one Input
+	//! instance can live per application. (Should this limitation ever get into
+	//! anyone's way, I will happily remove it; until then, I practice YAGNI.)
+    class Input
+    {
+        struct Impl;
+        boost::scoped_ptr<Impl> pimpl;
+
+	public:
+        #ifdef GOSU_IS_WIN
+        Input(HWND window);
+        #endif
+        
+        #ifdef GOSU_IS_MAC
+        Input(void* nswindow);
+        bool feedNSEvent(void* event);
+        #endif
+        
+        #ifdef GOSU_IS_X
+        Input(::Display* dpy);
+        bool feedXEvent(::XEvent& event, Window* window);
+        #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.
+		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;
+        // Undocumented for the moment.
+        void setMouseFactors(double factorX, double factorY);
+        
+        //! 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.
+        boost::function<void (Button)> onButtonDown, onButtonUp;
+        
+        TextInput* textInput() const;
+        void setTextInput(TextInput* input);
+    };
+}
+
+#endif

data/Gosu/Math.hpp

@@ -0,0 +1,95 @@
+//! \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 and max. Uses std::rand (so you have
+    //! to call std::srand before using it).
+    double random(double min, double max);
+
+    //! 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 between two points 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 positive angle between two angles.
+    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 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,61 @@
+//! \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 IDENTITY_FUN bigToNative
+#define IDENTITY_FUN2 nativeToBig
+#define CONV_FUN littleToNative
+#define CONV_FUN2 nativeToLittle
+#else
+#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
+
+#ifdef _MSC_VER
+#define GOSU_NORETURN __declspec(noreturn)
+#endif
+
+#ifdef __GNUC__
+#define GOSU_NORETURN __attribute__ ((noreturn))
+#endif
+
+#ifdef WIN32
+# define GOSU_IS_WIN
+#else
+# define GOSU_IS_UNIX
+# if defined(__linux) || defined(__FreeBSD__)
+#  define GOSU_IS_X
+# else
+#  define GOSU_IS_MAC
+# endif
+#endif
+
+#endif

data/Gosu/RotFlip.hpp

@@ -0,0 +1,116 @@
+//! \file RotFlip.hpp
+//! Interface of the undocumented RotFlip class.
+
+#ifndef GOSU_ROTFLIP_HPP
+#define GOSU_ROTFLIP_HPP
+
+namespace Gosu
+{
+    enum RotFlipName
+    {
+        rfDefault,
+        rfRotate90,
+        rfRotate180,
+        rfRotate270,
+
+        rfFlipX,
+        rfRotate90FlipX,
+        rfRotate180FlipX,
+        rfRotate270FlipX,
+        
+        rfFlipY          = rfRotate180FlipX,
+        rfRotate90FlipY  = rfRotate270FlipX,
+        rfRotate180FlipY = rfFlipX,
+        rfRotate270FlipY = rfRotate90FlipX,
+
+        rfFlipXRotate90  = rfRotate270FlipX,
+        rfFlipXRotate180 = rfRotate180FlipX,
+        rfFlipXRotate270 = rfRotate90FlipX,
+
+        rfFlipYRotate90  = rfRotate90FlipX,
+        rfFlipYRotate180 = rfFlipX,
+        rfFlipYRotate270 = rfRotate270FlipX
+    };
+
+    class RotFlip
+    {
+        RotFlipName name_;
+
+        typedef RotFlipName TransTable[8];
+        static const TransTable flipXTable, flipYTable, rotate90Table,
+            rotate180Table, rotate270Table;
+
+        typedef unsigned CornerTable[8][4];
+        static const CornerTable mapCornerTable, realCornerTable;
+
+    public:
+        RotFlip(RotFlipName name = rfDefault)
+        : name_(name)
+        {
+        }
+
+        RotFlipName name() const
+        {
+            return name_;
+        }
+
+        void flipX()
+        {
+            name_ = flipXTable[name_];
+        }
+
+        void flipY()
+        {
+            name_ = flipYTable[name_];
+        }
+
+        void rotate90()
+        {
+            name_ = rotate90Table[name_];
+        }
+
+        void rotate180()
+        {
+            name_ = rotate180Table[name_];
+        }
+
+        void rotate270()
+        {
+            name_ = rotate270Table[name_];
+        }
+
+        bool flipped() const
+        {
+            return name_ >= rfFlipX;
+        }
+
+        bool rotated() const
+        {
+            return name_ % 2 == 1;
+        }
+
+        unsigned mapCorner(unsigned n) const
+        {
+            return mapCornerTable[name_][n];
+        }
+
+        unsigned realCorner(unsigned n) const
+        {
+            return realCornerTable[name_][n];
+        }
+    };
+
+    inline bool operator==(RotFlip a, RotFlip b)
+    {
+        return a.name() == b.name();
+    }
+
+    inline bool operator!=(RotFlip a, RotFlip b)
+    {
+        return a.name() != b.name();
+    }
+
+    void applyToPoint(RotFlip rotFlip, int& x, int& y, int max);
+}
+
+#endif

data/Gosu/Sockets.hpp

@@ -0,0 +1,129 @@
+//! \file Sockets.hpp
+//! Interface of the three socket classes, MessageSocket, CommSocket and ListenerSocket.
+
+#ifndef GOSU_SOCKETS_HPP
+#define GOSU_SOCKETS_HPP
+
+#include <boost/cstdint.hpp>
+#include <boost/function.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <cstddef>
+#include <string>
+
+namespace Gosu
+{
+    // Both addresses and ports are returned from and given to Gosu
+    // functions in host byte order.
+    typedef boost::uint32_t SocketAddress;
+    typedef boost::uint16_t SocketPort;
+    const SocketPort anyPort = 0;
+
+    //! Tries to convert a dotted IP4 string into an address suitable for
+    //! socket functions. If the string supplied is not such a string, it
+    //! tries to look up the host via DNS. If both methods fail, zero is
+    //! returned.
+    SocketAddress stringToAddress(const std::string& s);
+    //! Converts an address into a dotted IP4 string.
+    std::string addressToString(SocketAddress address);
+
+    //! Wraps an UDP socket. Message sockets can send data to and receive
+    //! data from arbitrary addresses. Also, message sockets send messages
+    //! (packets) which are limited in size and can arrive in any order, or
+    //! not at all.
+    class MessageSocket
+    {
+        struct Impl;
+        boost::scoped_ptr<Impl> pimpl;
+
+    public:
+        //! Opens a message socket for listening at the specified port.
+        //! Gosu::anyPort may be passed to have the message socket use
+        //! a random free port.
+        explicit MessageSocket(SocketPort port);
+        ~MessageSocket();
+
+        //! Returns the local address of the socket.
+        SocketAddress address() const;
+        //! Returns the local port of the socket.
+        SocketPort port() const;
+        //! Returns the maximum size, in bytes, of a packet that can be sent
+        //! from this socket.
+        std::size_t maxMessageSize() const;
+
+        //! Collects all the packets that were sent to this socket and
+        //! calls onReceive for each of them.
+        void update();
+
+        //! Sends something to the given port of the computer identified
+        //! by the address.
+        void send(SocketAddress address, SocketPort port,
+            const void* buffer, std::size_t size);
+        /*void broadcast(SocketPort port, const void* buffer,
+            std::size_t size);*/
+
+        //! If assigned, will be called by update for every packet received.
+        boost::function<void (SocketAddress, SocketPort, const void*,
+            std::size_t)> onReceive;
+    };
+
+    enum CommMode
+    {
+        cmRaw,
+        //cmLines,
+        cmManaged
+    };
+
+    class Socket;
+
+    class CommSocket
+    {
+        struct Impl;
+        boost::scoped_ptr<Impl> pimpl;
+
+    public:
+        CommSocket(CommMode mode, SocketAddress targetAddress,
+            SocketPort targetPort);
+        CommSocket(CommMode mode, Socket& socket);
+        ~CommSocket();
+
+        SocketAddress address() const;
+        SocketPort port() const;
+        SocketAddress remoteAddress() const;
+        SocketPort remotePort() const;
+        CommMode mode() const;
+
+        bool connected() const;
+        void disconnect();
+        bool keepAlive() const;
+        void setKeepAlive(bool value);
+
+        void update();
+        void send(const void* buffer, std::size_t size);
+        void sendPendingData();
+        std::size_t pendingBytes() const;
+
+        boost::function<void (const void*, std::size_t)> onReceive;
+        boost::function<void ()> onDisconnection;
+    };
+
+    class ListenerSocket
+    {
+        struct Impl;
+        boost::scoped_ptr<Impl> pimpl;
+
+    public:
+        ListenerSocket(SocketPort port);
+        ~ListenerSocket();
+
+        SocketAddress address() const;
+        SocketPort port() const;
+
+        void update();
+
+        // This signal is fired by update() whenever someone connects
+        // to the port which is currently listened on.
+        boost::function<void (Socket&)> onConnection;
+    };
+}
+
+#endif