gosu 0.7.10.1

data/GosuImpl/AudioSDL.cpp

@@ -0,0 +1,255 @@
+#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 <map>
+#include <stdexcept>
+#include <vector>
+
+#include <SDL.h>
+#include <SDL_mixer.h>
+
+namespace Gosu {
+  namespace {
+    GOSU_NORETURN void throwLastSDLError() {
+      throw std::runtime_error(Mix_GetError());
+    }
+
+    bool mixerInitialized = false;
+    bool noSound = false;
+    Song* curSong = NULL;
+  }
+  
+  std::map<int, int> channelRegistry;
+}
+
+#ifdef GOSU_IS_WIN
+Gosu::Audio::Audio(HWND window) {
+  // Nothing to do; SDL_mixer does not require the window handle.
+#else
+Gosu::Audio::Audio() {
+#endif
+  if (mixerInitialized)
+    throw std::logic_error("Multiple Gosu::Audio instances not supported.");
+
+  if (SDL_Init(SDL_INIT_AUDIO) || Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 4096) < 0)
+    noSound = true;
+
+  mixerInitialized = true;
+}
+
+Gosu::Audio::~Audio() {
+  assert(mixerInitialized);
+
+  if (!noSound)
+    Mix_CloseAudio();
+  mixerInitialized = false;
+}
+
+Gosu::SampleInstance::SampleInstance(int handle, int extra)
+: handle(handle), extra(extra)
+{
+}
+
+bool Gosu::SampleInstance::playing() const
+{
+    return !noSound && channelRegistry[handle] == extra &&
+        Mix_Playing(handle) == 1;
+}
+
+void Gosu::SampleInstance::stop()
+{
+    if (playing())
+        Mix_HaltChannel(handle);
+}
+
+void Gosu::SampleInstance::changeVolume(double volume)
+{
+    if (playing())
+        Mix_Volume(handle, clamp<int>(volume * 255, 0, 255));
+}
+
+void Gosu::SampleInstance::changePan(double pan)
+{
+    int rightPan = clamp<int>(pan * 127, 0, 127);
+    if (playing())
+        Mix_SetPanning(handle, 254 - rightPan, rightPan);
+}
+
+void Gosu::SampleInstance::changeSpeed(double speed)
+{
+  /* We ignore the speed for now as this seems to be non-trivial
+   * with SDL_mixer. */
+}
+
+struct Gosu::Sample::SampleData : boost::noncopyable
+{
+  Mix_Chunk* rep;
+  
+  SampleData(): rep(0) {}
+  ~SampleData() {
+    if (rep != 0) Mix_FreeChunk(rep);
+  }
+};
+
+Gosu::Sample::Sample(Audio& audio, const std::wstring& filename)
+{
+  if (noSound)
+    return;
+
+  Buffer buf;
+  loadFile(buf, filename);
+
+  // Forward.
+  Sample(audio, buf.frontReader()).data.swap(data);
+}
+
+Gosu::Sample::Sample(Audio& audio, Reader reader) {
+  if (noSound)
+    return;
+
+  std::size_t bufsize = reader.resource().size() - reader.position();
+  Uint8* buffer = new Uint8[bufsize];
+  reader.read(buffer, bufsize);
+  
+  data.reset(new SampleData);
+  data->rep = Mix_LoadWAV_RW(SDL_RWFromMem(buffer, bufsize), 1);
+  if (data->rep == NULL)
+    throwLastSDLError();
+}
+
+Gosu::Sample::~Sample() {
+}
+
+Gosu::SampleInstance Gosu::Sample::play(double volume, double speed) const {
+  int channel;
+  
+  if (noSound || (channel = Mix_PlayChannel(-1, data->rep, 0)) == -1)
+    return SampleInstance(-1, -1);
+
+  int extra = ++channelRegistry[channel];
+  SampleInstance result(channel, extra);
+
+  if (volume != 1)
+      result.changeVolume(volume);
+
+  return result;
+
+  /* We ignore the speed for now as this seems to be non-trivial
+   * with SDL_mixer. */
+}
+
+Gosu::SampleInstance Gosu::Sample::playPan(double pan, double volume,
+    double speed) const {
+  int channel;
+  
+  if (noSound || (channel = Mix_PlayChannel(-1, data->rep, 0)) == -1)
+    return SampleInstance(-1, -1);
+
+  int extra = ++channelRegistry[channel];
+  SampleInstance result(channel, extra);
+
+  result.changePan(pan);
+
+  if (volume != 1)
+    result.changeVolume(volume);
+
+  return result;
+
+  /* Speed ignored for now, as above. */
+}
+
+// No class hierarchy here; SDL_mixer abstracts this away for us.
+class Gosu::Song::BaseData : boost::noncopyable {
+public:
+    Mix_Music* music;
+    //std::vector<Uint8> buffer; - used by constructor that has been commented out
+    double volume;
+    
+    BaseData() : music(0), volume(1.0) {}
+    ~BaseData() {
+      if (music) Mix_FreeMusic(music);
+    }
+
+    static void endSongCallback() {
+        curSong = 0;
+    }
+};
+
+Gosu::Song::Song(Audio& audio, const std::wstring& filename)
+: data(new BaseData)
+{
+    if (noSound)
+        return;
+
+    data->music = Mix_LoadMUS(Gosu::narrow(filename).c_str());
+    if (data->music == NULL)
+        throwLastSDLError();
+
+    Mix_HookMusicFinished(BaseData::endSongCallback);
+}
+
+Gosu::Song::Song(Audio &audio, Type type, Reader reader)
+: data(new BaseData)
+{
+#if 0
+    // Why oh why is LoadMUS_RW traditionally broken.
+    std::size_t bufsize = reader.resource().size() - reader.position();
+    data->buffer.resize(bufsize);
+    reader.read(data->buffer.data(), bufsize);
+    data->music = Mix_LoadMUS_RW(SDL_RWFromMem(data->buffer.data(), bufsize));
+    if (data->music == NULL)
+        throwLastSDLError();
+
+    Mix_HookMusicFinished(BaseData::endSongCallback);
+#else
+    throw std::runtime_error("Loading files from memory not possible with libSDL_mixer");
+#endif
+}
+
+Gosu::Song::~Song() {
+  stop();
+}
+
+void Gosu::Song::play() {
+  if (noSound)
+    return;
+
+  if (curSong)
+    curSong->stop();
+  
+  assert(curSong == 0);
+
+  if (Mix_PlayMusic(data->music, 0) < 0)
+    throwLastSDLError();
+  curSong = this;
+  changeVolume(data->volume);
+}
+
+void Gosu::Song::stop() {
+  if (playing()) {
+    Mix_HaltMusic();
+    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->volume = clamp(volume, 0.0, 1.0);
+
+  if (playing())
+    Mix_VolumeMusic(trunc(data->volume * MIX_MAX_VOLUME));
+}
+
+

data/GosuImpl/DirectoriesMac.mm

@@ -0,0 +1,38 @@
+#import <Gosu/Directories.hpp>
+#import <GosuImpl/MacUtility.hpp>
+#import <Gosu/Utility.hpp>
+#import <Foundation/NSAutoreleasePool.h>
+#import <Foundation/NSBundle.h>
+#import <Foundation/NSString.h>
+#import <Foundation/NSPathUtilities.h>
+
+std::wstring Gosu::resourcePrefix()
+{
+    static std::wstring result;
+    if (result.empty())
+    {
+        ObjRef<NSAutoreleasePool> pool([[NSAutoreleasePool alloc] init]);
+        NSBundle* bundle = [NSBundle mainBundle];
+        if (bundle == nil)
+            return L"";
+        NSString* str = [bundle resourcePath];
+        result = Gosu::widen([str fileSystemRepresentation]) + L"/";
+    }
+    return result;
+}
+
+std::wstring Gosu::sharedResourcePrefix()
+{
+    static std::wstring result;
+    if (result.empty())
+    {
+        ObjRef<NSAutoreleasePool> pool([[NSAutoreleasePool alloc] init]);
+        NSBundle* bundle = [NSBundle mainBundle];
+        if (bundle == nil)
+            return L"";
+        NSString* str = [bundle bundlePath];
+        str = [str stringByDeletingLastPathComponent];
+        result = Gosu::widen([str fileSystemRepresentation]) + L"/";
+    }
+    return result;
+}

data/GosuImpl/DirectoriesUnix.cpp

@@ -0,0 +1,48 @@
+#include <Gosu/Directories.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/Utility.hpp>
+#include <cassert>
+#include <vector>
+#include <sys/types.h>
+#include <unistd.h>
+#include <pwd.h>
+
+namespace 
+{
+    std::wstring homeDir()
+    {   
+        passwd* pwd = getpwuid(geteuid());
+        assert(pwd);
+        return Gosu::widen(pwd->pw_dir);
+    }
+}
+
+#ifndef GOSU_IS_MAC
+std::wstring Gosu::resourcePrefix()
+{
+    return std::wstring();
+}
+
+std::wstring Gosu::sharedResourcePrefix()
+{
+    return std::wstring();
+}
+#endif
+
+std::wstring Gosu::userSettingsPrefix()
+{
+#ifdef GOSU_IS_MAC
+    return homeDir() + L"/Library/Preferences/";
+#else
+    return homeDir() + L"/.";
+#endif
+}
+
+std::wstring Gosu::userDocsPrefix()
+{
+#ifdef GOSU_IS_MAC
+    return homeDir() + L"/Documents/";
+#else
+    return homeDir() + L"/";
+#endif
+}

data/GosuImpl/DirectoriesWin.cpp

@@ -0,0 +1,42 @@
+#include <Gosu/Directories.hpp>
+#include <Gosu/WinUtility.hpp>
+#include <cwchar>
+#include <stdexcept>
+#include <shlobj.h>
+
+namespace
+{
+	std::wstring specialFolderPath(int csidl)
+	{
+		WCHAR buf[MAX_PATH + 2];
+		if (!SHGetSpecialFolderPath(0, buf, csidl, TRUE))
+			throw std::runtime_error("Error getting special folder path");
+		std::size_t len = std::wcslen(buf);
+		if (buf[len - 1] != '\\')
+		{
+			buf[len] = L'\\';
+			buf[len + 1] = L'\0';
+		}
+		return buf;
+	}
+}
+
+std::wstring Gosu::resourcePrefix()
+{
+	return Win::appDirectory();
+}
+
+std::wstring Gosu::sharedResourcePrefix()
+{
+	return Win::appDirectory();
+}
+
+std::wstring Gosu::userSettingsPrefix()
+{
+	return specialFolderPath(CSIDL_APPDATA);
+}
+
+std::wstring Gosu::userDocsPrefix()
+{
+	return specialFolderPath(CSIDL_PERSONAL);
+}

data/GosuImpl/FileUnix.cpp

@@ -0,0 +1,100 @@
+#include <Gosu/IO.hpp>
+#include <Gosu/Utility.hpp>
+#include <stdexcept>
+#include <cstring>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+
+namespace
+{
+    // According to my man page, Unix folks just don't trust the 0, it's got to be a crippled -1.
+    void* const noMapping = reinterpret_cast<void*>(-1);
+}
+
+struct Gosu::File::Impl
+{
+    int fd;
+    void* mapping;
+    
+    Impl() : fd(-1), mapping(noMapping) {}
+    ~Impl()
+    {
+        if (fd > 0)
+            close(fd);
+    }
+};
+
+Gosu::File::File(const std::wstring& filename, FileMode mode)
+: pimpl(new Impl)
+{
+    int flags;
+
+    switch (mode)
+    {
+    case fmRead:
+        flags = O_RDONLY;
+        break;
+    case fmReplace:
+        flags = O_RDWR | O_TRUNC | O_CREAT;
+        break;
+    case fmAlter:
+        flags = O_RDWR | O_CREAT;
+        break;
+    }
+
+    // TODO: Locking flags?
+
+    pimpl->fd = open(narrow(filename).c_str(), flags,
+        S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
+    if (pimpl->fd < 0)
+        throw std::runtime_error("Cannot open file " + narrow(filename));
+    
+    if (mode == fmRead && size() > 0)
+        pimpl->mapping = mmap(0, size(), PROT_READ, 0, pimpl->fd, 0);
+}
+
+Gosu::File::~File()
+{
+    if (pimpl->mapping != noMapping)
+        munmap(pimpl->mapping, size());
+}
+
+std::size_t Gosu::File::size() const
+{
+    // IMPR: Error checking?
+    return lseek(pimpl->fd, 0, SEEK_END);
+}
+
+void Gosu::File::resize(std::size_t newSize)
+{
+    ftruncate(pimpl->fd, newSize);
+}
+
+void Gosu::File::read(std::size_t offset, std::size_t length,
+    void* destBuffer) const
+{
+    // TODO: err checking
+    if (pimpl->mapping != noMapping)
+    {
+        std::memcpy(destBuffer, static_cast<const char*>(pimpl->mapping) + offset, length);
+        return;
+    }
+    
+    // IMPR: Error checking?
+    lseek(pimpl->fd, offset, SEEK_SET);
+    ::read(pimpl->fd, destBuffer, length);
+}
+
+void Gosu::File::write(std::size_t offset, std::size_t length,
+    const void* sourceBuffer)
+{
+    // IMPR: Error checking?
+    lseek(pimpl->fd, offset, SEEK_SET);
+    ::write(pimpl->fd, sourceBuffer, length);
+}