gosu 0.15.2 → 1.1.0.pre2

data/src/MPEGFile.hpp

@@ -1,90 +0,0 @@
-#pragma once
-
-#include "AudioFile.hpp"
-#include <Gosu/IO.hpp>
-#include <algorithm>
-#include <stdexcept>
-#include <string>
-
-#include <mpg123.h>
-
-namespace Gosu
-{
-    class MPEGFile : public AudioFile
-    {
-        Gosu::Buffer contents_;
-        off_t position_ = 0;
-        mpg123_handle* handle_;
-        
-        enum {
-            SAMPLE_RATE = 44100,
-            INPUT_SIZE = 16384
-        };
-        
-    public:
-        MPEGFile(Gosu::Reader reader)
-        {
-            contents_.resize(reader.resource().size() - reader.position());
-            reader.read(contents_.data(), contents_.size());
-
-            static int init_error = mpg123_init();
-            if (init_error != MPG123_OK) {
-                throw std::runtime_error("Cannot initialize mpg123: " +
-                                         std::string(mpg123_plain_strerror(init_error)));
-            }
-
-            int new_error;
-            handle_ = mpg123_new(nullptr, &new_error);
-            if (handle_ == nullptr) {
-                throw std::runtime_error("Cannot initialize mpg123 decoder: " +
-                                         std::string(mpg123_plain_strerror(new_error)));
-            }
-            
-            mpg123_param(handle_, MPG123_FORCE_RATE, SAMPLE_RATE, 0);
-            mpg123_param(handle_, MPG123_FLAGS, MPG123_FORCE_STEREO, 0);
-            
-            mpg123_open_feed(handle_);
-        }
-        
-        ~MPEGFile() override
-        {
-            mpg123_delete(handle_);
-        }
-        
-        ALenum format() const override
-        {
-            return AL_FORMAT_STEREO16;
-        }
-        
-        ALuint sample_rate() const override
-        {
-            return SAMPLE_RATE;
-        }
-        
-        std::size_t read_data(void* dest, std::size_t length) override
-        {
-            std::size_t written = 0;
-            int error = 0;
-            
-            error = mpg123_read(handle_, static_cast<unsigned char*>(dest), length, &written);
-            while (written == 0
-                   && (error == MPG123_NEED_MORE || error == MPG123_NEW_FORMAT)
-                   && position_ != contents_.size()) {
-                auto bytes = std::min<std::size_t>(contents_.size() - position_, INPUT_SIZE);
-                // (Not sure what to do about the return value of mpg123_feed here.)
-                mpg123_feed(handle_, static_cast<unsigned char*>(contents_.data()) + position_,
-                            bytes);
-                position_ += bytes;
-                error = mpg123_read(handle_, static_cast<unsigned char*>(dest), length, &written);
-            }
-            
-            return written;
-        }
-        
-        void rewind() override
-        {
-            mpg123_feedseek(handle_, 0, SEEK_SET, &position_);
-            assert (position_ >= 0 && position_ <= contents_.size());
-        }
-    };
-}

data/src/OggFile.hpp

@@ -1,92 +0,0 @@
-#pragma once
-
-#include "AudioFile.hpp"
-#include <Gosu/IO.hpp>
-#include <stdexcept>
-#include <string>
-
-// Disable comma warnings in stb headers.
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcomma"
-#endif
-
-#define STB_VORBIS_HEADER_ONLY
-#include "stb_vorbis.c"
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-namespace Gosu
-{
-    class OggFile : public AudioFile
-    {
-        Gosu::Buffer contents_;
-        int channels_;
-        ALenum sample_rate_;
-        stb_vorbis* stream_;
-
-    public:
-        OggFile(Gosu::Reader reader)
-        {
-            contents_.resize(reader.resource().size() - reader.position());
-            reader.read(contents_.data(), contents_.size());
-            
-            int error = 0;
-            
-            auto data = static_cast<const unsigned char*>(contents_.data());
-            auto size = static_cast<int>(contents_.size());
-            stream_ = stb_vorbis_open_memory(data, size, &error, 0);
-            
-            if (stream_ == nullptr) {
-                throw std::runtime_error("Cannot open Ogg Vorbis file, error code: " +
-                                         std::to_string(error));
-            }
-            
-            stb_vorbis_info info = stb_vorbis_get_info(stream_);
-            channels_ = info.channels;
-            sample_rate_ = info.sample_rate;
-        }
-        
-        ~OggFile() override
-        {
-            stb_vorbis_close(stream_);
-            stream_ = nullptr;
-        }
-        
-        ALenum format() const override
-        {
-            return (channels_ == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16);
-        }
-        
-        ALuint sample_rate() const override
-        {
-            return sample_rate_;
-        }
-        
-        std::size_t read_data(void* dest, std::size_t length) override
-        {
-            int samples = 0;
-            int max_samples = static_cast<int>(length / sizeof(short));
-            
-            while (samples < max_samples) {
-                int samples_per_channel =
-                    stb_vorbis_get_samples_short_interleaved(stream_, channels_,
-                                                             static_cast<short*>(dest) + samples,
-                                                             max_samples - samples);
-                
-                if (samples_per_channel == 0) break;
-                
-                samples += samples_per_channel * channels_;
-            }
-            
-            return samples * sizeof(short);
-        }
-        
-        void rewind() override
-        {
-            stb_vorbis_seek_start(stream_);
-        }
-    };
-}

data/src/SampleWrapper.cpp

@@ -1,30 +0,0 @@
-#include <Gosu/Audio.hpp>
-#include <Gosu/Sample.h>
-
-extern "C" {
-
-Gosu_Sample *Gosu_Sample_create(const char *filename)
-{
-  return reinterpret_cast<Gosu_Sample *>( new Gosu::Sample(filename) );
-}
-
-void Gosu_Sample_destroy(Gosu_Sample *sample)
-{
-  delete( reinterpret_cast<Gosu::Sample *>( sample ) );
-}
-
-Gosu_Channel *Gosu_Sample_play(Gosu_Sample *sample, double volume, double speed, bool looping)
-{
-  Gosu::Channel channel = reinterpret_cast<Gosu::Sample *>( sample )->play(volume, speed, looping);
-
-  return reinterpret_cast<Gosu_Channel *>( new Gosu::Channel(channel) );
-}
-
-Gosu_Channel *Gosu_Sample_play_pan(Gosu_Sample *sample, double pan, double volume, double speed, bool looping)
-{
-  Gosu::Channel channel = reinterpret_cast<Gosu::Sample *>( sample )->play_pan(pan, volume, speed, looping);
-
-  return reinterpret_cast<Gosu_Channel *>( new Gosu::Channel(channel) );
-}
-
-}

data/src/SndFile.hpp

@@ -1,174 +0,0 @@
-#pragma once
-
-#include <Gosu/Audio.hpp>
-#include <Gosu/Platform.hpp>
-#include <Gosu/Utility.hpp>
-#include <sndfile.h>
-
-#ifdef GOSU_IS_WIN
-#define NOMINMAX
-#include <windows.h>
-#endif
-
-namespace Gosu
-{
-    class SndFile : public AudioFile
-    {
-        SNDFILE* file;
-        SF_INFO info;
-        Reader reader;
-        Buffer buffer;
-        
-        // /DELAYLOAD doesn't work with libsndfile.dll (is this still true?); manually lazy-load it.
-    #ifdef GOSU_IS_WIN
-        static HMODULE dll()
-        {
-            static HMODULE dll = LoadLibrary(L"libsndfile.dll");
-            if (!dll) throw std::runtime_error("Cannot find libsndfile.dll");
-            return dll;
-        }
-        
-    #define CREATE_STUB(NAME, RETURN, PARAMS, NAMES)                        \
-        static RETURN NAME PARAMS                                           \
-        {                                                                   \
-            typedef RETURN (__cdecl *NAME##_ptr) PARAMS;                    \
-            static NAME##_ptr f = (NAME##_ptr)GetProcAddress(dll(), #NAME); \
-            if (!f) {                                                       \
-                throw std::runtime_error("Cannot find " ## #NAME);          \
-            }                                                               \
-            return f NAMES;                                                 \
-        }
-        CREATE_STUB(sf_open_virtual, SNDFILE*,
-            (SF_VIRTUAL_IO* sfvirtual, int mode, SF_INFO* sfinfo, void* user_data),
-            (sfvirtual, mode, sfinfo, user_data))
-        CREATE_STUB(sf_close, int,
-            (SNDFILE* sndfile),
-            (sndfile))
-        CREATE_STUB(sf_readf_short, sf_count_t,
-            (SNDFILE* sndfile, short* ptr, sf_count_t items),
-            (sndfile, ptr, items))
-        CREATE_STUB(sf_seek, sf_count_t,
-            (SNDFILE* sndfile, sf_count_t frames, int whence),
-            (sndfile, frames, whence))
-        CREATE_STUB(sf_strerror, const char*,
-            (SNDFILE* sndfile),
-            (sndfile))
-    #undef CREATE_STUB
-    #endif
-        
-        static sf_count_t get_filelen(SndFile* self)
-        {
-            return self->buffer.size();
-        }
-        
-        static sf_count_t seek(sf_count_t offset, int whence, SndFile* self)
-        {
-            switch (whence) {
-            case SEEK_SET:
-                self->reader.set_position(offset);
-                break;
-            case SEEK_CUR:
-                self->reader.seek(offset);
-                break;
-            case SEEK_END:
-                self->reader.set_position(self->buffer.size() - offset);
-                break;
-            }
-
-            if (self->reader.position() > self->buffer.size()) {
-                self->reader.set_position(self->buffer.size());
-            }
-            
-            return 0;
-        }
-        
-        static sf_count_t read(void* ptr, sf_count_t count, SndFile* self)
-        {
-            sf_count_t avail = self->buffer.size() - self->reader.position();
-            count = std::min(avail, count);
-            self->reader.read(ptr, count);
-            return count;
-        }
-        
-        static sf_count_t tell(SndFile* self)
-        {
-            return self->reader.position();
-        }
-        
-        static SF_VIRTUAL_IO* io_interface()
-        {
-            static SF_VIRTUAL_IO io;
-            io.get_filelen = (sf_vio_get_filelen)&get_filelen;
-            io.seek        = (sf_vio_seek)&seek;
-            io.read        = (sf_vio_read)&read;
-            io.tell        = (sf_vio_tell)&tell;
-            io.write       = nullptr;
-            return &io;
-        }
-        
-    public:
-        SndFile(Reader reader)
-        : file(nullptr), reader(buffer.front_reader())
-        {
-            info.format = 0;
-            buffer.resize(reader.resource().size() - reader.position());
-            reader.read(buffer.data(), buffer.size());
-            file = sf_open_virtual(io_interface(), SFM_READ, &info, this);
-            if (!file) {
-                throw std::runtime_error(sf_strerror(nullptr));
-            }
-        }
-        
-        SndFile(const std::string& filename)
-        : file(nullptr), reader(buffer.front_reader())
-        {
-            info.format = 0;
-            // TODO: Not sure if this is still necessary.
-            // Can libsndfile open UTF-8 filenames on Windows?
-        #ifdef GOSU_IS_WIN
-            load_file(buffer, filename);
-            file = sf_open_virtual(io_interface(), SFM_READ, &info, this);
-        #else
-            file = sf_open(filename.c_str(), SFM_READ, &info);
-        #endif
-            if (!file) {
-                throw std::runtime_error(sf_strerror(nullptr));
-            }
-        }
-        
-        ~SndFile() override
-        {
-            if (file) {
-                sf_close(file);
-            }
-        }
-        
-        ALenum format() const override
-        {
-            switch (info.channels) {
-            case 1:
-                return AL_FORMAT_MONO16;
-            case 2:
-                return AL_FORMAT_STEREO16;
-            default:
-                throw std::runtime_error("Too many channels in audio file");
-            };
-        }
-        
-        ALuint sample_rate() const override
-        {
-            return info.samplerate;
-        }
-        
-        std::size_t read_data(void* dest, std::size_t length) override
-        {
-            int frame_size = sizeof(short) * info.channels;
-            return sf_readf_short(file, (short*)dest, length / frame_size) * frame_size;
-        }
-        
-        void rewind() override
-        {
-            sf_seek(file, 0, SEEK_SET);
-        }
-    };
-}

data/src/SongWrapper.cpp

@@ -1,52 +0,0 @@
-#include <Gosu/Audio.hpp>
-#include <Gosu/Song.h>
-
-extern "C" {
-  Gosu_Song* Gosu_Song_create(const char* filename)
-  {
-    return reinterpret_cast<Gosu_Song*>( new Gosu::Song(filename) );
-  }
-
-  void Gosu_Song_destroy(Gosu_Song* song)
-  {
-    delete( reinterpret_cast<Gosu::Song*>( song ));
-  }
-
-  void Gosu_Song_play(Gosu_Song* song, bool looping)
-  {
-    reinterpret_cast<Gosu::Song*>( song )->play(looping);
-  }
-
-  bool Gosu_Song_playing(Gosu_Song* song)
-  {
-    return reinterpret_cast<Gosu::Song*>( song )->playing();
-  }
-
-  void Gosu_Song_pause(Gosu_Song* song)
-  {
-    reinterpret_cast<Gosu::Song*>( song )->pause();
-  }
-
-  bool Gosu_Song_paused(Gosu_Song* song)
-  {
-    return reinterpret_cast<Gosu::Song*>( song )->paused();
-  }
-
-  void Gosu_Song_stop(Gosu_Song* song)
-  {
-    reinterpret_cast<Gosu::Song*>( song )->stop();
-  }
-
-  double Gosu_Song_volume(Gosu_Song* song){
-    return reinterpret_cast<Gosu::Song*>( song )->volume();
-  }
-
-  void Gosu_Song_set_volume(Gosu_Song* song, double volume){
-    return reinterpret_cast<Gosu::Song*>( song )->set_volume(volume);
-  }
-
-  Gosu_Song* Gosu_Song_current_song()
-  {
-    return reinterpret_cast<Gosu_Song*>(Gosu::Song::current_song());
-  }
-}

data/src/TextInputWrapper.cpp

@@ -1,101 +0,0 @@
-#include <Gosu/Gosu.hpp>
-
-namespace Gosu
-{
-class TextInputForWrapper : public Gosu::TextInput
-{
-public:
-    TextInputForWrapper();
-    std::string filter(std::string text) const override;
-    std::function<void (const char *text)> filter_callback;
-    std::string filter_result = "";
-};
-} // namespace Gosu
-
-Gosu::TextInputForWrapper::TextInputForWrapper() : Gosu::TextInput()
-{
-}
-
-std::string Gosu::TextInputForWrapper::filter(std::string text) const
-{
-    if (filter_callback != nullptr) {
-        filter_callback(text.c_str());
-        return filter_result;
-    }
-    else {
-        return text;
-    }
-}
-
-extern "C" {
-#include <Gosu/TextInput.h>
-
-Gosu_TextInput *Gosu_TextInput_create()
-{
-    return reinterpret_cast<Gosu_TextInput *>(new Gosu::TextInputForWrapper());
-}
-
-const char *Gosu_TextInput_text(Gosu_TextInput *text_input)
-{
-    thread_local std::string string;
-    string = reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->text();
-
-    return string.c_str();
-}
-
-void Gosu_TextInput_set_text(Gosu_TextInput *text_input, const char *text)
-{
-    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->set_text(text);
-}
-
-unsigned Gosu_TextInput_caret_pos(Gosu_TextInput *text_input)
-{
-    return reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->caret_pos();
-}
-
-void Gosu_TextInput_set_caret_pos(Gosu_TextInput *text_input, unsigned pos)
-{
-    return reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->set_caret_pos(pos);
-}
-
-unsigned Gosu_TextInput_selection_start(Gosu_TextInput *text_input)
-{
-    return reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->selection_start();
-}
-
-void Gosu_TextInput_set_selection_start(Gosu_TextInput *text_input, unsigned pos)
-{
-    return reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->set_selection_start(pos);
-}
-
-void Gosu_TextInput_set_filter(Gosu_TextInput *text_input, void function(void *data, const char *text), void *data)
-{
-    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->filter_callback = [=](const char *text) { function(data, text); };
-}
-
-void Gosu_TextInput_set_filter_result(Gosu_TextInput *text_input, const char *result)
-{
-    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->filter_result = result;
-}
-
-void Gosu_TextInput_insert_text(Gosu_TextInput *text_input, const char *text)
-{
-    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->insert_text(text);
-}
-
-void Gosu_TextInput_delete_backward(Gosu_TextInput *text_input)
-{
-    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->delete_backward();
-}
-
-void Gosu_TextInput_delete_forward(Gosu_TextInput *text_input)
-{
-    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->delete_forward();
-}
-
-void Gosu_TextInput_destroy(Gosu_TextInput *text_input)
-{
-    delete (reinterpret_cast<Gosu::TextInputForWrapper *>(text_input));
-}
-
-}