gosu 0.7.39-x86-mingw32

data/COPYING

@@ -0,0 +1,34 @@
+Copyright (C) 2004-2011 Julian Raschke, Jan Lücker and all contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+                  Julian Raschke  julian@raschke.de
+                  Jan Lücker     jan.luecker@gmx.de
+                        http://www.libgosu.org/
+
+                                  ***
+
+This does NOT apply to audiere.dll shipped with the Windows versions of
+Gosu. Audiere is a separate library licensed under the Lesser General
+Public License. Please consult http://audiere.sf.net/ for more details.
+
+This does also NOT apply to libogg and libvorbis, which are included in
+all source and binary distributions of Gosu, sometimes via audiere. These
+projects are licensed under a BSD-like license, and their copyright terms
+need to be supplied even with binary redistributions (e.g. Gosu games).

data/Gosu/Async.hpp

@@ -0,0 +1,50 @@
+// Undocumented for the first few iterations. Interface may change rapidly.
+// This is mainly a proof of concept. Stability will be the highest on OS X.
+
+#if 0
+#ifndef GOSU_ASYNC_HPP
+#define GOSU_ASYNC_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/TR1.hpp>
+#include <thread>
+#include <memory>
+#include <string>
+
+namespace Gosu
+{
+    template<typename Result>
+    class AsyncResult
+    {
+        std::tr1::shared_ptr<std::tr1::try_mutex> mutex;
+        std::tr1::shared_ptr<std::auto_ptr<Result> > result;
+        
+    public:
+        AsyncResult(const std::tr1::shared_ptr<std::tr1::try_mutex>& mutex,
+                    const std::tr1::shared_ptr<std::auto_ptr<Result> >& result)
+        : mutex(mutex), result(result)
+        {
+        }
+        
+        bool hasValue() const
+        {
+            std::tr1::try_mutex::scoped_try_lock lock(*mutex);
+            return lock && result->get();
+        }
+        
+        std::auto_ptr<Result> takeValue()
+        {
+            std::tr1::try_mutex::scoped_lock lock(*mutex);
+            return *result;
+        }
+    };
+    
+	// TODO: Will only work if the window doesn't die inbetween.
+	// TODO: More functions to come; or a general interface?
+
+	AsyncResult<Image>
+		asyncNewImage(Window& window, const std::wstring& filename);
+}
+
+#endif
+#endif

data/Gosu/Audio.hpp

@@ -0,0 +1,163 @@
+//! \file Audio.hpp
+//! Contains all the classes of Gosu's audio system.
+
+#ifndef GOSU_AUDIO_HPP
+#define GOSU_AUDIO_HPP
+
+#ifdef WIN32
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#endif
+#include <Gosu/Fwd.hpp>
+#include <Gosu/IO.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/TR1.hpp>
+#include <memory>
+#include <string>
+
+namespace Gosu
+{
+    // Deprecated.
+    #ifndef SWIG
+    GOSU_DEPRECATED class Audio;
+    #endif
+
+    //! An instance of a Sample playing. Can be used to stop sounds dynamically,
+    //! or to check if they are finished.
+    //! It is recommended that you throw away sample instances if possible,
+    //! as they could accidentally refer to other sounds being played after
+    //! a very long time has passed.
+	class SampleInstance
+	{
+		int handle, extra;
+        bool alive() const;		
+
+	public:
+        //! Called by Sample, do not use.
+		SampleInstance(int handle, int extra);
+
+		bool playing() const;
+		bool paused() const;
+        //! Pauses this instance to be resumed afterwards. It will still keep a channel filled while paused.
+        void pause();
+        void resume();
+        //! Stops this instance of a sound being played.
+        //! Calling this twice, or too late, does not do any harm.
+		void stop();
+
+        //! \param volume Can be anything from 0.0 (silence) to 1.0 (full
+        //! volume).
+        void changeVolume(double volume);
+        //! \param pan Can be anything from -1.0 (left) to 1.0 (right).
+        void changePan(double pan);
+        //! \param speed Playback speed is only limited by FMOD's
+        //! capabilities and can accept very high or low values. Use 1.0 for
+        //! normal playback speed.
+        void changeSpeed(double speed);
+	};
+
+    //! A sample is a short sound that is completely loaded in memory, can be
+    //! played multiple times at once and offers very flexible playback
+    //! parameters. Use samples for everything that's not music.
+    class Sample
+    {
+        struct SampleData;
+        std::tr1::shared_ptr<SampleData> data;
+    
+    public:
+        //! Constructs a sample that can be played on the specified audio
+        //! system and loads the sample from a file.
+        explicit Sample(const std::wstring& filename);
+        
+        //! Constructs a sample that can be played on the specified audio
+        //! system and loads the sample data from a stream.
+        explicit Sample(Reader reader);
+        
+        //! Plays the sample without panning.
+        //! \param volume Can be anything from 0.0 (silence) to 1.0 (full
+        //! volume).
+        //! \param speed Playback speed is only limited by the underlying audio library,
+        //! and can accept very high or low values. Use 1.0 for
+        //! normal playback speed.
+        SampleInstance play(double volume = 1, double speed = 1,
+            bool looping = false) const;
+
+        //! Plays the sample with panning. Even if pan is 0.0, the sample will
+        //! not be as loud as if it were played by calling play() due to the
+        //! way the panning works.
+        //! \param pan Can be anything from -1.0 (left) to 1.0 (right).
+        //! \param volume Can be anything from 0.0 (silence) to 1.0 (full
+        //! volume).
+        //! \param speed Playback speed is only limited by by the underlying audio library,
+        //! and can accept very high
+        //! or low values. Use 1.0 for normal playback speed.
+        SampleInstance playPan(double pan, double volume = 1, double speed = 1,
+            bool looping = false) const;
+
+        #ifndef SWIG
+        GOSU_DEPRECATED Sample(Audio& audio, const std::wstring& filename);
+        GOSU_DEPRECATED Sample(Audio& audio, Reader reader);
+        #endif
+    };
+
+    //! Songs are less flexible than samples in that they can only be played
+    //! one at a time and without panning or speed parameters.
+    class Song
+    {
+        class BaseData;
+        class ModuleData;
+        class StreamData;
+        Song(const Song&);
+        Song& operator=(const Song&);
+        std::auto_ptr<BaseData> data;
+    
+    public:
+        //! Constructs a song that can be played on the provided audio system
+        //! and loads the song from a file. The type is determined from the
+        //! filename.
+        explicit Song(const std::wstring& filename);
+        
+        //! Constructs a song of the specified type that can be played on the
+        //! provided audio system and loads the song data from a stream.
+        explicit Song(Reader reader);
+        
+        ~Song();
+        
+        //! Returns the song currently being played or paused, or 0 if
+        //! no song has been played yet or the last song has finished
+        //! playing.
+        static Song* currentSong();
+        
+        //! Starts or resumes playback of the song. This will stop all other
+        //! songs and set the current song to this object.
+        void play(bool looping = false);
+        //! Pauses playback of the song. It is not considered being played.
+        //! currentSong will stay the same.
+        void pause();
+        //! Returns true if the song is the current song, but in paused
+        //! mode.
+        bool paused() const;
+        //! Stops playback of this song if it is currently played or paused.
+        //! Afterwards, currentSong will return 0.
+        void stop();
+        //! Returns true if the song is currently playing.
+        bool playing() const;
+        //! Returns the current volume of the song.
+        double volume() const;
+        //! Changes the volume of the song.
+        void changeVolume(double volume);
+        
+        //! Called every tick by Window for management purposes.
+        static void update();
+
+        #ifndef SWIG
+        enum Type { stStream, stModule };
+        GOSU_DEPRECATED Song(Audio&, const std::wstring& filename);
+        GOSU_DEPRECATED Song(Audio&, Type type, Reader reader);
+        #endif
+    };
+}
+
+#endif

data/Gosu/AutoLink.hpp

@@ -0,0 +1,16 @@
+//! \file AutoLink.hpp
+//! Contains pragmas that make MSVC link against all the necessary libraries
+//! automatically.
+
+#ifdef _MSC_VER
+#ifndef GOSU_AUTOLINK_HPP
+#define GOSU_AUTOLINK_HPP
+
+#ifdef NDEBUG
+#pragma comment(lib, "Gosu.lib")
+#else
+#pragma comment(lib, "GosuDebug.lib")
+#endif
+
+#endif
+#endif

data/Gosu/Bitmap.hpp

@@ -0,0 +1,96 @@
+//! \file Bitmap.hpp
+//! Interface of the Bitmap class.
+
+#ifndef GOSU_BITMAP_HPP
+#define GOSU_BITMAP_HPP
+
+#include <Gosu/Color.hpp>
+#include <Gosu/Fwd.hpp>
+#include <Gosu/GraphicsBase.hpp>
+#include <Gosu/Platform.hpp>
+#include <string>
+#include <vector>
+
+namespace Gosu
+{
+    //! Rectangular area of pixels, each represented by a Color value. Provides
+    //! minimal drawing functionality and serves as a temporary holder for
+    //! graphical resources which are usually turned into Images later.
+    //! Has (expensive) value semantics.
+    class Bitmap
+    {
+        unsigned w, h;
+        std::vector<Color> pixels;
+
+    public:
+        Bitmap() : w(0), h(0) {}
+        Bitmap(unsigned w, unsigned h, Color c = Color::NONE) : w(w), h(h), pixels(w * h, c) {}
+
+        unsigned width()  const { return w; }
+        unsigned height() const { return h; }
+
+        void swap(Bitmap& other);
+
+        void resize(unsigned width, unsigned height, Color c = Color::NONE);
+        
+        //! Returns the color at the specified position. x and y must be on the
+        //! bitmap.
+        Color getPixel(unsigned x, unsigned y) const { return pixels[y * w + x]; }
+
+        //! Sets the pixel at the specified position to a color. x and y must
+        //! be on the bitmap.
+        void setPixel(unsigned x, unsigned y, Color c) { pixels[y * w + x] = c; }
+
+        //! Inserts a bitmap at the given position. Parts of the inserted
+        //! bitmap that would be outside of the target bitmap will be
+        //! clipped away.
+        void insert(const Bitmap& source, int x, int y);
+
+        //! Inserts a portion of a bitmap at the given position. Parts of the
+        //! inserted bitmap that would be outside of the target bitmap will be
+        //! clipped away.
+        void insert(const Bitmap& source, int x, int y, unsigned srcX,
+            unsigned srcY, unsigned srcWidth, unsigned srcHeight);
+		
+        //! Direct access to the array of color values. May be useful for optimized
+        //! OpenGL operations.
+        const Color* data() const { return &pixels[0]; }
+        Color* data() { return &pixels[0]; }
+
+        // Work with data() instead if you need fast operations.
+        GOSU_DEPRECATED void fill(Color c);
+        GOSU_DEPRECATED void replace(Color oldColor, Color newColor);
+    };
+    
+    //! Loads any supported image into a Bitmap.
+    void loadImageFile(Bitmap& bitmap, const std::wstring& filename);
+    //! Loads any supported image into a Bitmap.
+    void loadImageFile(Bitmap& bitmap, Reader input);
+    
+    //! Saves a Bitmap to a file.
+    void saveImageFile(const Bitmap& bitmap, const std::wstring& filename);
+    //! Saves a Bitmap to an arbitrary resource.
+    void saveImageFile(const Bitmap& bitmap, Gosu::Writer writer,
+        const std::wstring& formatHint = L"png");
+
+    //! Set the alpha value of all pixels which are equal to the color key
+    //! to zero. Color values are adjusted so that no borders show up when
+    //! the image is stretched or rotated.
+    void applyColorKey(Bitmap& bitmap, Color key);
+    
+    //! The reverse of applyColorKey. Resets all fully transparent pixels by
+    //! a background color, makes all other pixels fully opaque.
+    void unapplyColorKey(Bitmap& bitmap, Color background);
+    
+    void applyBorderFlags(Bitmap& dest, const Bitmap& source,
+        unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
+        unsigned borderFlags);	
+
+    // Use loadImageFile/saveImageFile instead.
+    GOSU_DEPRECATED Reader loadFromBMP(Bitmap& bmp, Reader reader);
+    GOSU_DEPRECATED Writer saveToBMP(const Bitmap& bmp, Writer writer);
+    GOSU_DEPRECATED Reader loadFromPNG(Bitmap& bmp, Reader reader);
+    GOSU_DEPRECATED Writer saveToPNG(const Bitmap& bmp, Writer writer);
+}
+
+#endif

data/Gosu/ButtonsMac.hpp

@@ -0,0 +1,140 @@
+#ifndef GOSU_BUTTONSMAC_HPP
+#define GOSU_BUTTONSMAC_HPP
+
+namespace Gosu
+{
+    //! List of button ids that can be used with Gosu::Input.
+    //! This enumeration contains ids for keyboard keys (kb*),
+    //! mouse buttons and mouse wheel (ms*) and gamepad buttons (gp*).
+    enum ButtonName
+    {
+        kbRangeBegin = 0x00,
+        kbEscape = 0x35,
+        kbF1 = 0x7a,
+        kbF2 = 0x78,
+        kbF3 = 0x63,
+        kbF4 = 0x76,
+        kbF5 = 0x60,
+        kbF6 = 0x61,
+        kbF7 = 0x62,
+        kbF8 = 0x64,
+        kbF9 = 0x65,
+        kbF10 = 0x6d,
+        kbF11 = 0x67,
+        kbF12 = 0x6f,
+        kb1 = 0x12,
+        kb2 = 0x13,
+        kb3 = 0x14,
+        kb4 = 0x15,
+        kb5 = 0x17,
+        kb6 = 0x16,
+        kb7 = 0x1a,
+        kb8 = 0x1c,
+        kb9 = 0x19,
+        kb0 = 0x1d,
+        kbA	= 0x00,
+        kbB	= 0x0b,
+        kbC	= 0x08,
+        kbD	= 0x02,
+        kbE	= 0x0e,
+        kbF	= 0x03,
+        kbG	= 0x05,
+        kbH	= 0x04,
+        kbI	= 0x22,
+        kbJ	= 0x26,
+        kbK	= 0x28,
+        kbL	= 0x25,
+        kbM	= 0x2e,
+        kbN	= 0x2d,
+        kbO	= 0x1f,
+        kbP	= 0x23,
+        kbQ	= 0x0c,
+        kbR	= 0x0f,
+        kbS	= 0x01,
+        kbT	= 0x11,
+        kbU	= 0x20,
+        kbV	= 0x09,
+        kbW	= 0x0d,
+        kbX	= 0x07,
+        kbY	= 0x10,
+        kbZ	= 0x06,
+        kbTab = 0x30,
+        kbReturn = 0x24,
+        kbSpace = 0x31,
+        kbLeftShift = 0x38,
+        kbRightShift = 0x3c,
+        kbLeftControl = 0x3b,
+        kbRightControl = 0x3e,
+        kbLeftAlt = 0x3a,
+        kbRightAlt = 0x3d,
+        kbLeftMeta = 0x37,
+        kbRightMeta = 0x36,
+        kbBackspace = 0x33,
+        kbLeft = 0x7b,
+        kbRight = 0x7c,
+        kbUp = 0x7e,
+        kbDown = 0x7d,
+        kbHome = 0x73,
+        kbEnd = 0x77,
+        kbInsert = 0x72,
+        kbDelete = 0x75,
+        kbPageUp = 0x74,
+        kbPageDown = 0x79,
+        kbEnter = 0x4c,
+        kbNumpad1 = 0x53,
+        kbNumpad2 = 0x54,
+        kbNumpad3 = 0x55,
+        kbNumpad4 = 0x56,
+        kbNumpad5 = 0x57,
+        kbNumpad6 = 0x58,
+        kbNumpad7 = 0x59,
+        kbNumpad8 = 0x5b,
+        kbNumpad9 = 0x5c,
+        kbNumpad0 = 0x52,
+        kbNumpadAdd = 0x45,
+        kbNumpadSubtract = 0x4e,
+        kbNumpadMultiply = 0x43,
+        kbNumpadDivide = 0x4b,
+        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 + 1,
+		noButton = 0xffffffff
+    };
+}
+    
+#endif