gosu 0.7.10.1

data/Gosu/Text.hpp

@@ -0,0 +1,47 @@
+//! \file Text.hpp
+//! Functions to output text on bitmaps.
+
+#ifndef GOSU_TEXT_HPP
+#define GOSU_TEXT_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/GraphicsBase.hpp>
+#include <string>
+
+namespace Gosu
+{
+    //! Returns the name of a neutral font that is available on the current
+    //! platform.
+    std::wstring defaultFontName();
+
+    //! Returns the width a text would span on a bitmap if it were drawn
+    //! using drawText with the same arguments.
+    //! \param fontName Name of a system font, or a filename to a TTF file (must contain '/').
+    unsigned textWidth(const std::wstring& text,
+        const std::wstring& fontName, unsigned fontHeight,
+        unsigned fontFlags = 0);
+
+    //! Draws a line of text on a bitmap.
+    //! \param fontName Name of a system font, or a filename to a TTF file (must contain '/').
+    //! \param fontHeight Height, in pixels, of the text.
+    //! \param fontFlags Binary combination of members of the FontFlags
+    //! enum.
+    void drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
+        Color c, const std::wstring& fontName, unsigned fontHeight,
+        unsigned fontFlags = 0);
+
+    //! Creates a bitmap that is filled with the text given to the function.
+    //! The text may contain line breaks.
+    //! \param fontName Name of a system font, or a filename to a TTF file (must contain '/').
+    //! \param fontHeight Height of the font in pixels.
+    //! \param lineSpacing Spacing between two lines of text in pixels.
+    //! \param maxWidth Maximal width of the bitmap that will be returned. Text
+    //! will be split into multiple lines to avoid drawing over the right
+    //! border. When a single word is too long, it will be truncated.
+    Bitmap createText(const std::wstring& text,
+        const std::wstring& fontName, unsigned fontHeight, 
+        unsigned lineSpacing, unsigned maxWidth, TextAlign align,
+        unsigned fontFlags = 0);
+}
+
+#endif

data/Gosu/TextInput.hpp

@@ -0,0 +1,57 @@
+//! \file TextInput.hpp
+//! Interface of the TextInput class.
+
+#ifndef GOSU_TEXTINPUT_HPP
+#define GOSU_TEXTINPUT_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/Platform.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <string>
+
+namespace Gosu
+{
+    //! TextInput instances are invisible objects that build a text string from input,
+    //! using the current operating system's keyboard layout.
+    //! At its most basic form, you only need to create a new TextInput instance and
+    //! pass it to your window via setTextInput. Until you call this function again,
+    //! passing 0, the TextInput object will build a text that can be accessed via
+    //! TextInput::text().
+    //! A TextInput object is purely abstract, though; drawing the input field is left
+    //! to the user. As with most of Gosu, how this is handled is completely left open.
+    //! TextInput only aims to provide enough code for your own GUIs to build upon.
+    class TextInput
+    {
+        struct Impl;
+        boost::scoped_ptr<Impl> pimpl;
+        
+    public:
+        TextInput();
+        ~TextInput();
+
+        std::wstring text() const;
+
+        //! Replaces the current text by the given string and positions the cursor
+        //! at the end of the text, with an empty selection.
+        void setText(const std::wstring& text);
+
+        //! Position of the caret as the index of the character that it's left to.
+        unsigned caretPos() const;
+
+        //! If there is a selection, the selectionStart() member yields its beginning,
+        //! using the same indexing scheme as caretPos. If there is no selection,
+        //! selectionStart() is equal to caretPos().
+        unsigned selectionStart() const;
+
+        // Platform-specific communication with Gosu::Input.
+        #if defined(GOSU_IS_MAC)
+        bool feedNSEvent(void* event);
+        #elif defined(GOSU_IS_WIN)
+        bool feedMessage(unsigned long message, unsigned long wparam, unsigned long lparam);
+        #elif defined(GOSU_IS_X)
+        bool feedXEvent(void* display, void* event);
+        #endif
+    };
+}
+
+#endif

data/Gosu/Timing.hpp

@@ -0,0 +1,16 @@
+//! \file Timing.hpp
+//! Functions for timing.
+
+#ifndef GOSU_TIMING_HPP
+#define GOSU_TIMING_HPP
+
+namespace Gosu
+{
+    //! Freezes the current thread for at least the specified time.
+    void sleep(unsigned milliseconds);
+
+    //! Incrementing, possibly wrapping millisecond timer.
+    unsigned long milliseconds();
+}
+
+#endif

data/Gosu/Utility.hpp

@@ -0,0 +1,24 @@
+//! \file Utility.hpp
+//! General purpose utility functions.
+
+// REDESIGN: Rename to StringConversion.hpp?
+
+#ifndef GOSU_UTILITY_HPP
+#define GOSU_UTILITY_HPP
+
+#include <string>
+#include <vector>
+
+namespace Gosu
+{
+    //! Converts an std::string into an std::wstring.
+    std::wstring widen(const std::string& s);
+    //! Converts an std::wstring into an std::string.
+    std::string narrow(const std::wstring& ws);
+    
+    // Undocumented, temporary: Please ignore. ;)
+    std::wstring utf8ToWstring(const std::string& utf8);
+    std::string wstringToUTF8(const std::wstring& ws);
+}
+
+#endif

data/Gosu/WinUtility.hpp

@@ -0,0 +1,76 @@
+//! \file WinUtility.hpp
+//! Contains some functions which are used to implement Gosu on Windows and
+//! might be useful for advanced users who try to integrate Gosu in a Win32
+//! application.
+
+#ifndef GOSU_WINUTILITY_HPP
+#define GOSU_WINUTILITY_HPP
+
+#include <windows.h>
+#include <Gosu/Platform.hpp>
+#include <boost/function.hpp>
+#include <boost/shared_ptr.hpp>
+#include <string>
+
+namespace Gosu
+{
+    //! Implementation helpers for the Windows platform.
+    namespace Win
+    {
+        //! Returns the instance handle of the application.
+        HINSTANCE instance();
+
+        //! Blocking function which waits for the next message, processes it,
+        //! then returns.
+        void handleMessage();
+
+        //! Non-blocking function which processes all waiting messages but does
+        //! not wait for further incoming messages.
+        void processMessages();
+
+        //! Registers a function to be called by handleMessage and
+        //! processMessages. Every message is passed to the hooks and not
+        //! processed further if any hook function returns true.
+        void registerMessageHook(const boost::function<bool (MSG&)>& hook);
+        
+        //! Throws an exception according to the error which GetLastError()
+        //! returns, optionally prefixed with "While <action>, the following
+        //! error occured: ".
+        GOSU_NORETURN void throwLastError(const std::string& action = "");
+
+        //! Small helper function that throws an exception whenever the value
+        //! passed through is false. Note that this doesn't make sense for all
+        //! Windows API functions, but for most of them.
+        template<typename T>
+        inline T check(T valToCheck, const std::string& action = "")
+        {
+            if (!valToCheck)
+                throwLastError(action);
+            return valToCheck;
+        }
+
+        // IMPR: Why can't I use mem_fn for releasing objects even though it is
+        // shown like that in the shared_ptr documentation?
+        template<typename T>
+        void releaseComPtr(T* ptr)
+        {
+            ptr->Release();
+        }
+
+        //! Small helper function that transfers ownership of a COM interface
+        //! to a boost::shared_ptr.
+        template<typename T>
+        inline boost::shared_ptr<T> shareComPtr(T* ptr)
+        {
+            return boost::shared_ptr<T>(ptr, releaseComPtr<T>);
+        }
+
+        //! Returns the executable's filename.
+        std::wstring appFilename();
+
+        //! Returns the executable's containing directory.
+        std::wstring appDirectory();
+    }
+}
+
+#endif

data/Gosu/Window.hpp

@@ -0,0 +1,84 @@
+//! \file Window.hpp
+//! Interface of the Window class.
+
+#ifndef GOSU_WINDOW_HPP
+#define GOSU_WINDOW_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/Input.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+#include <string>
+
+#ifdef GOSU_IS_WIN
+#include <windows.h>
+#endif
+
+namespace Gosu
+{
+    //! Convenient all-in-one class that serves as the foundation of a standard
+	//! Gosu application. Manages initialization of all of Gosu's core components
+    //! and provides timing functionality.
+    class Window
+    {
+        struct Impl;
+        boost::scoped_ptr<Impl> pimpl;
+
+    public:
+        //! Constructs a Window.
+        //! \param updateInterval Interval in milliseconds between two calls
+        //! to the update member function.
+        Window(unsigned width, unsigned height, bool fullscreen,
+            double updateInterval = 16.666666);
+        virtual ~Window();
+
+        std::wstring caption() const;
+        void setCaption(const std::wstring& caption);
+
+        //! Starts the main event loop.
+        void show();
+        //! Closes the window if it is currently shown.
+        void close();
+
+        //! Called every updateInterval milliseconds while the window is being
+        //! shown. Your application's main game logic goes here.
+        virtual void update() {}
+        //! Called after every update and when the OS wants the window to
+        //! repaint itself. Your application's rendering code goes here.
+        virtual void draw() {}
+
+        //! Called before update when the user pressed a button while the
+        //! window had the focus.
+        virtual void buttonDown(Gosu::Button) {}
+        //! Same as buttonDown. Called then the user released a button.
+        virtual void buttonUp(Gosu::Button) {}
+        
+        // Ignore when SWIG is wrapping this class for Ruby/Gosu.
+        #ifndef SWIG
+        const Graphics& graphics() const;
+        Graphics& graphics();
+
+        const Audio& audio() const;
+        Audio& audio();
+
+        const Input& input() const;
+        Input& input();
+
+        #ifdef GOSU_IS_WIN
+        // Only on Windows.
+        HWND handle() const;
+        virtual LRESULT handleMessage(UINT message, WPARAM wparam,
+            LPARAM lparam);
+        #else
+        // Only on Unices (so far).
+        typedef boost::shared_ptr<boost::function<void()> > SharedContext;
+        SharedContext createSharedContext();
+        #endif
+
+        #endif
+    };
+}
+
+#endif

data/GosuImpl/Async.cpp

@@ -0,0 +1,37 @@
+#include <Gosu/Async.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Image.hpp>
+#include <Gosu/Window.hpp>
+#include <boost/bind.hpp>
+
+using namespace boost;
+
+namespace Gosu
+{
+    namespace
+    {
+        void asyncNewImage_Impl(Window& window, std::wstring filename,
+                            Window::SharedContext context,
+                            shared_ptr<try_mutex> mutex,
+                            shared_ptr<std::auto_ptr<Image> > result)
+        {
+            try_mutex::scoped_lock lock(*mutex);
+            (*context)();
+            result->reset(new Image(window.graphics(), filename));
+        }
+    }
+}
+
+Gosu::AsyncResult<Gosu::Image>
+    Gosu::asyncNewImage(Window& window, const std::wstring& filename)
+{
+	shared_ptr<try_mutex> mutex(new try_mutex);
+	shared_ptr<std::auto_ptr<Image> > image(new std::auto_ptr<Image>);
+	thread thread(bind(asyncNewImage_Impl,
+						ref(window),
+                        filename,
+						window.createSharedContext(),
+						mutex,
+                        image));
+	return AsyncResult<Image>(mutex, image);
+}

data/GosuImpl/AudioFmod.cpp

@@ -0,0 +1,417 @@
+#include <Gosu/Audio.hpp>
+#include <Gosu/Math.hpp>
+#include <Gosu/IO.hpp>
+#include <Gosu/Utility.hpp>
+#include <boost/algorithm/string.hpp>
+#include <cassert>
+#include <cstdlib>
+#include <algorithm>
+#include <stdexcept>
+#include <vector>
+
+#include <fmod.h>
+#include <fmod_errors.h>
+
+namespace Gosu
+{
+    namespace
+    {
+        GOSU_NORETURN void throwLastFMODError()
+        {
+            throw std::runtime_error(FMOD_ErrorString(FSOUND_GetError()));
+        }
+
+        inline unsigned char fmodCheck(unsigned char retVal)
+        {
+            if (retVal == 0 && FSOUND_GetError() != FMOD_ERR_NONE)
+                throwLastFMODError();
+
+            return retVal;
+        }
+
+        bool fmodInitialized = false;
+        Song* curSong = 0;
+
+        #ifdef GOSU_IS_WIN
+        bool setWindow(HWND window)
+        {
+            // Copied and pasted from MSDN.
+            #define FACILITY_VISUALCPP  ((LONG)0x6d)
+            #define VcppException(sev,err)  ((sev) | (FACILITY_VISUALCPP<<16) | err)
+            #define BAD_MOD VcppException(ERROR_SEVERITY_ERROR, ERROR_MOD_NOT_FOUND)
+
+            // Try to call the first function from fmod.dll, which is lazily
+            // linked. With this guard, we can raise a catchable C++ exception
+            // if the library is not found, instead of crashing the game.
+            __try
+            {
+                FSOUND_SetHWND(reinterpret_cast<void*>(window));
+            }
+            __except ((GetExceptionCode() == BAD_MOD) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+            {
+                return false;
+            }
+            return true;
+
+            #undef BAD_MOD
+            #undef VcppException
+            #undef FACILITY_VISUALCPP
+        }
+        #endif
+    }
+}
+
+#ifdef GOSU_IS_WIN
+Gosu::Audio::Audio(HWND window)
+{
+    if (!setWindow(window))
+        throw std::runtime_error("Could not load fmod.dll");
+#else
+Gosu::Audio::Audio()
+{
+#endif
+
+    if (fmodInitialized)
+        throw std::logic_error("Multiple Gosu::Audio instances not supported");
+
+    fmodCheck(FSOUND_Init(44100, 32, 0));
+    fmodInitialized = true;
+}
+
+Gosu::Audio::~Audio()
+{
+    assert(fmodInitialized);
+
+    FSOUND_Close();
+    fmodInitialized = false;
+}
+
+Gosu::SampleInstance::SampleInstance(int handle, int extra)
+: handle(handle), extra(extra)
+{
+}
+
+bool Gosu::SampleInstance::playing() const
+{
+    return FSOUND_IsPlaying(handle);
+}
+
+void Gosu::SampleInstance::stop()
+{
+    FSOUND_StopSound(handle);
+}
+
+void Gosu::SampleInstance::changeVolume(double volume)
+{
+    FSOUND_SetVolume(handle, clamp<int>(volume * 255, 0, 255));
+}
+
+void Gosu::SampleInstance::changePan(double pan)
+{
+    FSOUND_SetPan(handle, clamp<int>(pan * 127 + 127, 0, 255));
+}
+
+void Gosu::SampleInstance::changeSpeed(double speed)
+{
+    FSOUND_SetFrequency(handle, clamp<int>(speed * extra, 100, 705600));
+}
+
+struct Gosu::Sample::SampleData : boost::noncopyable
+{
+    FSOUND_SAMPLE* rep;
+
+    SampleData()
+    : rep(0)
+    {
+    }
+
+    ~SampleData()
+    {
+        // Should be checked for earlier, as play would crash too.
+        // This is just because it's hard to free things in the right
+        // order in Ruby/Gosu.
+        
+        if (!fmodInitialized)
+            return;
+        
+        if (rep != 0)
+            FSOUND_Sample_Free(rep);
+    }
+};
+
+Gosu::Sample::Sample(Audio& audio, const std::wstring& filename)
+{
+	Buffer buf;
+	loadFile(buf, filename);
+
+	// Forward.
+	Sample(audio, buf.frontReader()).data.swap(data);
+}
+
+Gosu::Sample::Sample(Audio& audio, Reader reader)
+{
+    std::vector<char> buffer(reader.resource().size() - reader.position());
+    reader.read(&buffer.front(), buffer.size());
+
+    data.reset(new SampleData);
+    data->rep = FSOUND_Sample_Load(FSOUND_FREE | FSOUND_UNMANAGED,
+        &buffer.front(), FSOUND_NORMAL | FSOUND_LOADMEMORY, 0, buffer.size());
+    if (data->rep == 0)
+        throwLastFMODError();
+}
+
+Gosu::Sample::~Sample()
+{
+}
+
+Gosu::SampleInstance Gosu::Sample::play(double volume, double speed) const
+{
+    int handle = FSOUND_PlaySound(FSOUND_FREE, data->rep);
+    int freq;
+    if (handle > 0)
+    {
+        freq = FSOUND_GetFrequency(handle);
+        FSOUND_SetPan(handle, FSOUND_STEREOPAN);
+    }
+    
+    SampleInstance result(handle, freq);
+    result.changeVolume(volume);
+    result.changeSpeed(speed);
+    return result;
+}
+
+Gosu::SampleInstance Gosu::Sample::playPan(double pan, double volume, double speed) const
+{
+    int handle = FSOUND_PlaySound(FSOUND_FREE, data->rep);
+    int freq;
+    if (handle > 0)
+    {
+        freq = FSOUND_GetFrequency(handle);
+    }
+    
+    SampleInstance result(handle, freq);
+    result.changeVolume(volume);
+    result.changePan(pan);
+    result.changeSpeed(speed);
+    return result;
+}
+
+class Gosu::Song::BaseData : boost::noncopyable
+{
+    double volume_;
+
+protected:
+    BaseData() : volume_(1) {}
+    virtual void applyVolume() = 0;
+
+public:
+    virtual ~BaseData() {}
+
+    virtual void play() = 0;
+    virtual void stop() = 0;
+    
+    double volume() const
+    {
+        return volume_;
+    }
+    
+    void changeVolume(double volume)
+    {
+        volume_ = clamp(volume, 0.0, 1.0);
+        applyVolume();
+    }
+};
+
+class Gosu::Song::StreamData : public BaseData
+{
+    FSOUND_STREAM* stream;
+    int handle;
+    std::vector<char> buffer;
+
+    static signed char F_CALLBACKAPI endSongCallback(FSOUND_STREAM*, void*,
+        int, void* self)
+    {
+        curSong = 0;
+        static_cast<StreamData*>(self)->handle = -1;
+        return 0;
+    }
+
+public:
+    StreamData(Gosu::Reader reader)
+    : stream(0), handle(-1)
+    {
+        buffer.resize(reader.resource().size() - reader.position());
+        reader.read(&buffer[0], buffer.size());
+
+// Disabled for licensing reasons.
+// If you have a license to play MP3 files, compile with GOSU_ALLOW_MP3.
+#ifndef GOSU_ALLOW_MP3
+        if (buffer.size() > 2 &&
+            ((buffer[0] == '\xff' && (buffer[1] & 0xfe) == '\xfa') ||
+            (buffer[0] == 'I' && buffer[1] == 'D' && buffer[2] == '3')))
+        {
+            throw std::runtime_error("MP3 file playback not allowed");
+        }
+#endif
+
+        stream = FSOUND_Stream_Open(&buffer[0], FSOUND_LOADMEMORY, 0,
+            buffer.size());
+        if (stream == 0)
+            throwLastFMODError();
+        
+        FSOUND_Stream_SetEndCallback(stream, endSongCallback, this);
+    }
+    
+    ~StreamData()
+    {
+        // TODO: Should be checked for earlier, as play would crash too.
+        // This is just because Ruby's GC will free objects in a weird
+        // order.
+        if (!fmodInitialized)
+            return;
+
+        if (stream != 0)
+            FSOUND_Stream_Close(stream);
+    }
+    
+    void play()
+    {
+        handle = FSOUND_Stream_Play(FSOUND_FREE, stream);
+        applyVolume();
+    }
+    
+    void stop()
+    {
+        fmodCheck(FSOUND_Stream_Stop(stream));
+    }
+    
+    void applyVolume()
+    {
+        if (handle != -1)
+            FSOUND_SetVolume(handle, static_cast<int>(volume() * 255));
+    }
+};
+
+class Gosu::Song::ModuleData : public Gosu::Song::BaseData
+{
+    FMUSIC_MODULE* module_;
+
+public:
+    ModuleData(Reader reader)
+    : module_(0)
+    {
+        std::vector<char> buffer(reader.resource().size() - reader.position());
+        reader.read(&buffer[0], buffer.size());
+
+        module_ = FMUSIC_LoadSongEx(&buffer[0], 0, buffer.size(),
+            FSOUND_LOADMEMORY | FSOUND_LOOP_OFF, 0, 0);
+        if (module_ == 0)
+            throwLastFMODError();
+    }
+
+    ~ModuleData()
+    {
+        // TODO: Should be checked for earlier, as play would crash too.
+        // This is just because Ruby's GC will free objects in a weird
+        // order.
+        if (!fmodInitialized)
+            return;
+
+        if (module_ != 0)
+            FMUSIC_FreeSong(module_);
+    }
+
+    void play()
+    {
+        FMUSIC_PlaySong(module_);
+        applyVolume();
+    }
+
+    void stop()
+    {
+        fmodCheck(FMUSIC_StopSong(module_));
+    }
+    
+    void applyVolume()
+    {
+        // Weird as it may seem, the FMOD doc really says volume can
+        // be 0 to 256, *inclusive*, for this function.
+        FMUSIC_SetMasterVolume(module_, static_cast<int>(volume() * 256.0));
+    }
+};
+
+Gosu::Song::Song(Audio& audio, const std::wstring& filename)
+{
+    Buffer buf;
+	loadFile(buf, filename);
+	Type type = stStream;
+    
+	using boost::iends_with;
+	if (iends_with(filename, ".mod") || iends_with(filename, ".mid") ||
+	    iends_with(filename, ".s3m") || iends_with(filename, ".it") ||
+	    iends_with(filename, ".xm"))
+	{
+	      type = stModule;
+	}
+	
+    // Forward.
+	Song(audio, type, buf.frontReader()).data.swap(data);
+}
+
+Gosu::Song::Song(Audio& audio, Type type, Reader reader)
+{
+    switch (type)
+    {
+    case stStream:
+        data.reset(new StreamData(reader));
+        break;
+
+    case stModule:
+        data.reset(new ModuleData(reader));
+        break;
+
+    default:
+        throw std::logic_error("Invalid song type");
+    }
+}
+
+Gosu::Song::~Song()
+{
+    if (fmodInitialized)
+        stop();
+}
+
+void Gosu::Song::play()
+{
+    if (curSong)
+        curSong->stop();
+
+    assert(curSong == 0);
+
+    data->play();
+    curSong = this;
+}
+
+void Gosu::Song::stop()
+{
+    if (playing())
+    {
+        data->stop();
+        curSong = 0;
+    }
+}
+
+bool Gosu::Song::playing() const
+{
+    return curSong == this;
+}
+
+double Gosu::Song::volume() const
+{
+    return data->volume();
+}
+
+void Gosu::Song::changeVolume(double volume)
+{
+    data->changeVolume(volume);
+}