gosu 1.0.0 → 1.2.0

data/src/ImageWrapper.cpp

@@ -1,168 +0,0 @@
-#include <Gosu/Gosu.hpp>
-#include <stdio.h>
-#include <cstring>
-
-extern "C" {
-#include <Gosu/Image.h>
-
-// Constructors
-Gosu_Image *Gosu_Image_create(const char *filename, unsigned image_flags)
-{
-    return reinterpret_cast<Gosu_Image *>(new Gosu::Image(filename, image_flags));
-};
-
-Gosu_Image *Gosu_Image_create_from_markup(const char *markup, const char *font, double font_height,
-                                            int width, double spacing, unsigned align, unsigned font_flags, unsigned image_flags)
-{
-    Gosu::Bitmap bitmap = Gosu::layout_markup(markup, font, font_height, spacing, width,
-                                                (Gosu::Alignment)align, font_flags);
-    return reinterpret_cast<Gosu_Image *>(new Gosu::Image(bitmap, image_flags));
-}
-
-Gosu_Image *Gosu_Image_create_from_text(const char *text, const char *font, double font_height,
-                                        int width, double spacing, unsigned align, unsigned font_flags, unsigned image_flags)
-{
-    Gosu::Bitmap bitmap = Gosu::layout_text(text, font, font_height, spacing, width,
-                                            (Gosu::Alignment)align, font_flags);
-    return reinterpret_cast<Gosu_Image *>(new Gosu::Image(bitmap, image_flags));
-}
-
-Gosu_Image *Gosu_Image_create_from_blob(unsigned char *blob, int byte_count, int columns, int rows, unsigned image_flags)
-{
-    std::size_t size = columns * rows * 4;
-    Gosu::Bitmap bitmap(columns, rows, Gosu::Color::NONE);
-
-    if (byte_count == size) {
-        // 32 bit per pixel, assume R8G8B8A8
-        std::memcpy(bitmap.data(), blob, size);
-    }
-    else if (byte_count == size * sizeof(float)) {
-        // 128 bit per channel, assume float/float/float/float
-        const float *in = reinterpret_cast<const float *>(blob);
-        Gosu::Color::Channel *out = reinterpret_cast<Gosu::Color::Channel *>(bitmap.data());
-        for (int i = size; i > 0; --i) {
-            *(out++) = static_cast<Gosu::Color::Channel>(*(in++) * 255);
-        }
-    }
-    else {
-        return nullptr; // abort?
-    }
-
-    return reinterpret_cast<Gosu_Image *>(new Gosu::Image(bitmap, image_flags));
-}
-
-Gosu_Image *Gosu_Image_create_from_subimage(Gosu_Image *image, int left, int top, int width, int height)
-{
-    Gosu::Image *gosu_image = reinterpret_cast<Gosu::Image *>(image);
-    std::unique_ptr<Gosu::ImageData> image_data = gosu_image->data().subimage(left, top, width, height);
-
-    return reinterpret_cast<Gosu_Image *>(image_data.get() ? new Gosu::Image(std::move(image_data)) : nullptr);
-}
-
-void Gosu_Image_create_from_tiles(const char *source, int tile_width, int tile_height, void function(void *data, Gosu_Image *image), void *data, unsigned image_flags)
-{
-    std::vector<Gosu::Image> gosu_images = Gosu::load_tiles(source, tile_width, tile_height, image_flags);
-
-    for (Gosu::Image &img : gosu_images) {
-        function(data, reinterpret_cast<Gosu_Image *>(new Gosu::Image(img)));
-    }
-}
-
-void Gosu_Image_create_tiles_from_image(Gosu_Image *image, int tile_width, int tile_height, void function(void *data, Gosu_Image *image), void *data, unsigned image_flags)
-{
-    std::vector<Gosu::Image> gosu_images = Gosu::load_tiles(reinterpret_cast<Gosu::Image *>(image)->data().to_bitmap(), tile_width, tile_height, image_flags);
-
-    for (Gosu::Image &img : gosu_images) {
-        function(data, reinterpret_cast<Gosu_Image *>(new Gosu::Image(img)));
-    }
-}
-
-// Properties
-unsigned Gosu_Image_width(Gosu_Image *image)
-{
-    return reinterpret_cast<Gosu::Image *>(image)->width();
-}
-
-unsigned Gosu_Image_height(Gosu_Image *image)
-{
-    return reinterpret_cast<Gosu::Image *>(image)->height();
-}
-
-Gosu_GLTexInfo *Gosu_Image_gl_tex_info_create(Gosu_Image *image)
-{
-    Gosu::Image *gosu_image = reinterpret_cast<Gosu::Image *>(image);
-    Gosu::GLTexInfo *gosu_texture_info = new Gosu::GLTexInfo(*gosu_image->data().gl_tex_info());
-    if (gosu_texture_info) {
-        return reinterpret_cast<Gosu_GLTexInfo *>(gosu_texture_info);
-    }
-    else {
-        return nullptr;
-    }
-}
-
-void Gosu_Image_gl_tex_info_destroy(Gosu_GLTexInfo *gl_tex_info)
-{
-    delete (reinterpret_cast<Gosu::GLTexInfo *>(gl_tex_info));
-}
-
-// Rendering
-void Gosu_Image_draw(Gosu_Image *image, double x, double y, double z, double scale_x, double scale_y, unsigned color, unsigned mode)
-{
-    reinterpret_cast<Gosu::Image *>(image)->draw(x, y, z, scale_x, scale_y, color, (Gosu::AlphaMode)mode);
-}
-
-void Gosu_Image_draw_rot(Gosu_Image *image, double x, double y, double z,
-                            double angle, double center_x, double center_y,
-                            double scale_x, double scale_y, unsigned color, unsigned mode)
-{
-    reinterpret_cast<Gosu::Image *>(image)->draw_rot(x, y, z,
-                                                        angle, center_x, center_y,
-                                                        scale_x, scale_y,
-                                                        color, (Gosu::AlphaMode)mode);
-}
-
-void Gosu_Image_draw_as_quad(Gosu_Image *image,
-                                double x1, double y1, unsigned color1,
-                                double x2, double y2, unsigned color2,
-                                double x3, double y3, unsigned color3,
-                                double x4, double y4, unsigned color4,
-                                double z, unsigned mode)
-{
-    Gosu::Image *gosu_image = reinterpret_cast<Gosu::Image *>(image);
-    gosu_image->data().draw(
-        x1, y1, color1,
-        x2, y2, color2,
-        x3, y3, color3,
-        x4, y4, color4,
-        z, (Gosu::AlphaMode)mode);
-}
-
-// Image operations
-void Gosu_Image_insert(Gosu_Image *image, Gosu_Image *source, int x, int y)
-{
-    Gosu::Bitmap bmp;
-    bmp = reinterpret_cast<Gosu::Image *>(source)->data().to_bitmap();
-    reinterpret_cast<Gosu::Image *>(image)->data().insert(bmp, x, y);
-}
-
-unsigned char *Gosu_Image_to_blob(Gosu_Image *image)
-{
-    Gosu::Image *gosu_image = reinterpret_cast<Gosu::Image *>(image);
-    static thread_local Gosu::Bitmap bitmap;
-    bitmap = gosu_image->data().to_bitmap();
-
-    return reinterpret_cast<unsigned char *>(bitmap.data());
-}
-
-void Gosu_Image_save(Gosu_Image *image, const char *filename)
-{
-    Gosu::save_image_file(reinterpret_cast<Gosu::Image *>(image)->data().to_bitmap(), filename);
-}
-
-// Destructor
-void Gosu_Image_destroy(Gosu_Image *image)
-{
-    delete (reinterpret_cast<Gosu::Image *>(image));
-}
-
-}

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/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/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));
-}
-
-}

data/src/UtilityApple.cpp

@@ -1,16 +0,0 @@
-#include <Gosu/Platform.hpp>
-#if defined(GOSU_IS_MAC)
-
-#import <Gosu/Utility.hpp>
-#import <Foundation/Foundation.h>
-using namespace std;
-
-string Gosu::language()
-{
-    @autoreleasepool {
-        NSString* language = [NSLocale preferredLanguages][0];
-        return language.UTF8String ?: "en";
-    }
-}
-
-#endif