gosu 0.10.9.pre1 → 0.11.0

data/src/TimingWin.cpp

@@ -1,6 +1,9 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_WIN)
+
 #include <Gosu/Timing.hpp>
-#include <windows.h>
 #include <cstdlib>
+#include <windows.h>
 
 void Gosu::sleep(unsigned milliseconds)
 {
@@ -12,3 +15,5 @@ unsigned long Gosu::milliseconds()
     static unsigned long start = (timeBeginPeriod(1), timeGetTime());
     return timeGetTime() - start;
 }
+
+#endif

data/src/{Graphics/Transform.cpp → Transform.cpp}

@@ -1,24 +1,26 @@
 // Default matrices, adapted from original Transform support
 // contribution by erisdiscord. Thank you!
 
+#include "GraphicsImpl.hpp"
 #include <Gosu/GraphicsBase.hpp>
 #include <Gosu/Math.hpp>
-#include "Common.hpp"
 #include <cmath>
 
 Gosu::Transform
-Gosu::rotate(double angle, double aroundX, double aroundY)
+Gosu::rotate(double angle, double around_x, double around_y)
 {
-    double c = std::cos(degreesToRadians(angle));
-    double s = std::sin(degreesToRadians(angle));
+    double c = std::cos(degrees_to_radians(angle));
+    double s = std::sin(degrees_to_radians(angle));
     Gosu::Transform result = {
         +c, +s, 0, 0,
         -s, +c, 0, 0,
         0,  0,  1, 0,
         0,  0,  0, 1
     };
-    if (aroundX != 0 || aroundY != 0)
-        result = concat(concat(translate(-aroundX, -aroundY), result), translate(aroundX, aroundY));
+    if (around_x != 0 || around_y != 0) {
+        result = concat(concat(translate(-around_x, -around_y), result),
+                        translate(around_x, around_y));
+    }
     return result;
 }
 
@@ -47,16 +49,18 @@ Gosu::scale(double factor)
 }
 
 Gosu::Transform
-Gosu::scale(double factorX, double factorY, double aroundX, double aroundY)
+Gosu::scale(double scale_x, double scale_y, double around_x, double around_y)
 {
     Gosu::Transform result = {
-        factorX, 0,       0, 0,
-        0,       factorY, 0, 0,
+        scale_x, 0,       0, 0,
+        0,       scale_y, 0, 0,
         0,       0,       1, 0,
         0,       0,       0, 1
     };
-    if (aroundX != 0 || aroundY != 0)
-        result = concat(concat(translate(-aroundX, -aroundY), result), translate(aroundX, aroundY));
+    if (around_x != 0 || around_y != 0) {
+        result = concat(concat(translate(-around_x, -around_y), result),
+                        translate(around_x, around_y));
+    }
     return result;
 }
 
@@ -66,8 +70,9 @@ Gosu::concat(const Transform& left, const Transform& right)
     Gosu::Transform result;
     for (int i = 0; i < 16; ++i) {
         result[i] = 0;
-        for (int j = 0; j < 4; ++j)
+        for (int j = 0; j < 4; ++j) {
             result[i] += left[i / 4 * 4 + j] * right[i % 4 + j * 4];
+        }
     }
     return result;
 }

data/src/{Graphics/TransformStack.hpp → TransformStack.hpp}

@@ -1,7 +1,6 @@
-#ifndef GOSU_SRC_GRAPHICS_TRANSFORMSTACK_HPP
-#define GOSU_SRC_GRAPHICS_TRANSFORMSTACK_HPP
+#pragma once
 
-#include "Common.hpp"
+#include "GraphicsImpl.hpp"
 #include <cassert>
 #include <algorithm>
 
@@ -14,14 +13,14 @@ namespace Gosu
         // All the absolute matrices that have been created since last reset.
         Transforms absolute;
         // Points to one absolute transform.
-        Transforms::const_iterator currentIterator;
+        Transforms::const_iterator current_iterator;
         
-        void makeCurrent(const Transform& transform)
+        void make_current(const Transform& transform)
         {
-            currentIterator =
-                std::find(absolute.begin(), absolute.end(), transform);
-            if (currentIterator == absolute.end())
-                currentIterator = absolute.insert(absolute.end(), transform);
+            current_iterator = std::find(absolute.begin(), absolute.end(), transform);
+            if (current_iterator == absolute.end()) {
+                current_iterator = absolute.insert(absolute.end(), transform);
+            }
         }
         
     public:
@@ -30,7 +29,7 @@ namespace Gosu
             reset();
             individual.front() = absolute.front() = scale(1);
         }
-                
+
         void reset()
         {
             // Every queue has a base transform that is always the current transform.
@@ -38,7 +37,7 @@ namespace Gosu
             // set a base transform in the main rendering queue.
             individual.resize(1);
             absolute.resize(1);
-            currentIterator = absolute.begin();
+            current_iterator = absolute.begin();
         }
         
         TransformStack(const TransformStack& other)
@@ -46,41 +45,43 @@ namespace Gosu
             *this = other;
         }
         
-        // Custom assignment to ensure valid currentIterator
-        TransformStack& operator=(const TransformStack &other)
+        // Custom assignment to ensure valid current_iterator
+        TransformStack& operator=(const TransformStack& other)
         {
             individual = other.individual;
             absolute = other.absolute;
             
-            // Reset our currentIterator to point to the respective element
+            // Reset our current_iterator to point to the respective element
             // in our own 'absolute' transforms by iterating both lists up to
             // the other lists' current iterator
-            currentIterator = absolute.begin();
-            Transforms::const_iterator otherIterator = other.absolute.begin();
-            while (otherIterator != other.currentIterator)
-                ++currentIterator, ++otherIterator;
+            current_iterator = absolute.begin();
+            Transforms::const_iterator other_iterator = other.absolute.begin();
+            while (other_iterator != other.current_iterator) {
+                ++current_iterator;
+                ++other_iterator;
+            }
             
             return *this;
         }
         
-        void setBaseTransform(const Transform& baseTransform)
+        void set_base_transform(const Transform& base_transform)
         {
             assert (individual.size() == 1);
             assert (absolute.size() == 1);
             
-            individual.front() = absolute.front() = baseTransform;
+            individual.front() = absolute.front() = base_transform;
         }
         
         const Transform& current()
         {
-            return *currentIterator;
+            return *current_iterator;
         }
         
         void push(const Transform& transform)
         {
             individual.push_back(transform);
             Transform result = concat(transform, current());
-            makeCurrent(result);
+            make_current(result);
         }
         
         void pop()
@@ -92,9 +93,7 @@ namespace Gosu
             for (Transforms::reverse_iterator it = individual.rbegin(),
                     end = individual.rend(); it != end; ++it)
                 result = concat(result, *it);
-            makeCurrent(result);
+            make_current(result);
         }
     };
 }
-
-#endif

data/src/Utility.cpp

@@ -2,10 +2,11 @@
 #include <Gosu/Platform.hpp>
 #include <cstddef>
 #include <cstdlib>
-#include <cwctype>
+#include <cstring>
 #include <cwchar>
-#include <stdexcept>
+#include <cwctype>
 #include <algorithm>
+#include <stdexcept>
 #include <vector>
 
 #ifndef GOSU_IS_IPHONE
@@ -16,7 +17,8 @@
 using namespace std;
 
 #ifndef GOSU_IS_WIN
-namespace {
+namespace
+{
     extern const char UTF_8[] = "UTF-8";
 #ifdef __BIG_ENDIAN__
     extern const char UCS_4_INTERNAL[] = "UCS-4BE";
@@ -25,95 +27,52 @@ namespace {
 #endif
 }
 
-wstring Gosu::utf8ToWstring(const string& s)
+wstring Gosu::utf8_to_wstring(const string& s)
 {
     return iconvert<wstring, UCS_4_INTERNAL, UTF_8>(s);
 }
-string Gosu::wstringToUTF8(const std::wstring& ws)
+string Gosu::wstring_to_utf8(const std::wstring& ws)
 {
     return iconvert<string, UTF_8, UCS_4_INTERNAL>(ws);
 }
 
-#ifdef GOSU_IS_MAC
-// This is only necessary on OS X (for text output)
-// TODO: Move to respective files now that iconvert<> has been extracted
-// from this file.
-
-namespace {
-    extern const char UCS_2_INTERNAL[] = "UCS-2-INTERNAL";
-}
-
-namespace Gosu {
-    vector<unsigned short> wstringToUniChars(const wstring& ws)
-    {
-        return iconvert<vector<unsigned short>, UCS_2_INTERNAL, UCS_4_INTERNAL>(ws);
-    }
-}
-#endif
 #else
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 #include <windows.h>
-wstring Gosu::utf8ToWstring(const string& utf8)
+wstring Gosu::utf8_to_wstring(const string& utf8)
 {
-	vector<wchar_t> buffer(utf8.size() + 1);
-	MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), utf8.size() + 1, &buffer[0], buffer.size());
-	return &buffer[0];
-}	
-string Gosu::wstringToUTF8(const wstring& ws)
+    vector<wchar_t> buffer(utf8.size() + 1);
+    MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), utf8.size() + 1, &buffer[0], buffer.size());
+    return &buffer[0];
+}
+string Gosu::wstring_to_utf8(const wstring& ws)
 {
-	unsigned size = WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), ws.size(), 0, 0, 0, 0);
-	vector<char> buffer(size + 1);
-	WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), ws.size(), &buffer[0], buffer.size(), 0, 0);
-	return &buffer[0];
+    unsigned size = WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), ws.size(), 0, 0, 0, 0);
+    vector<char> buffer(size + 1);
+    WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), ws.size(), &buffer[0], buffer.size(), 0, 0);
+    return &buffer[0];
 }
 #endif
-
-wstring Gosu::widen(const string& s)
-{
-#ifdef GOSU_IS_X
-    setlocale(LC_ALL, "");
 #endif
 
-    size_t wideLen = std::mbstowcs(0, s.c_str(), 0);
-    if (wideLen == static_cast<size_t>(-1))
-        throw std::runtime_error("Could not convert from string to wstring: " + s);
-
-    vector<wchar_t> buf(wideLen + 1);
-    mbstowcs(&buf.front(), s.c_str(), buf.size());
-
-    return wstring(buf.begin(), buf.end() - 1);
-}
-
-string Gosu::narrow(const wstring& ws)
+bool Gosu::has_extension(const std::string& filename, const char* extension)
 {
-    size_t narrowLen = std::wcstombs(0, ws.c_str(), 0);
-    if (narrowLen == static_cast<size_t>(-1))
-        throw std::runtime_error("Could not convert from wstring to string: " + string(ws.begin(), ws.end()));
-
-    vector<char> buf(narrowLen + 1);
-    wcstombs(&buf.front(), ws.c_str(), buf.size());
-
-    return string(buf.begin(), buf.end() - 1);
-}
-
-#endif
+    size_t ext_len = strlen(extension);
+    if (ext_len > filename.length()) {
+        return false;
+    }
 
-// TODO: This function needs to go into some internal header.
-namespace Gosu
-{
-    bool isExtension(const wchar_t* str, const wchar_t* ext)
-    {
-        size_t strLen = wcslen(str), extLen = wcslen(ext);
-        if (extLen > strLen)
+    const char* str = filename.c_str() + filename.length();
+    const char* ext = extension + ext_len;
+    while (ext_len--) {
+        if (tolower((int) *--str) != *--ext) {
             return false;
-        str += strLen, ext += extLen;
-        while (extLen--)
-            if (towlower((wint_t)*--str) != *--ext)
-                return false;
-        return true;
+        }
     }
+
+    return true;
 }
 
 #if defined(GOSU_IS_UNIX) && !defined(GOSU_IS_MAC)

data/src/UtilityApple.cpp

@@ -0,0 +1,52 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_MAC)
+
+#import <Gosu/Utility.hpp>
+#import <Foundation/Foundation.h>
+#import <stdexcept>
+#import <vector>
+
+#ifdef GOSU_IS_IPHONE
+std::wstring Gosu::utf8_to_wstring(const std::string& s)
+{
+    if (s.empty()) {
+        return std::wstring();
+    }
+    
+    NSString* string = [NSString stringWithUTF8String:s.c_str()];
+    std::vector<wchar_t> buffer(s.size());
+    NSUInteger buffer_size;
+    if (![string getBytes:&buffer[0]
+                maxLength:buffer.size() * sizeof(wchar_t)
+               usedLength:&buffer_size
+                 encoding:NSUTF32LittleEndianStringEncoding
+                  options:0
+                    range:NSMakeRange(0, string.length)
+           remainingRange:nullptr]) {
+        throw std::runtime_error("String " + s + " could not be converted to UTF-32");
+    }
+    return std::wstring(&buffer[0], &buffer[0] + buffer_size / sizeof(wchar_t));
+}
+
+std::string Gosu::wstring_to_utf8(const std::wstring& ws)
+{
+    if (ws.empty()) return std::string();
+
+    @autoreleasepool {
+        NSString* string = [[NSString alloc] initWithBytes:ws.data()
+                                                    length:ws.size() * sizeof(wchar_t)
+                                                  encoding:NSUTF32LittleEndianStringEncoding];
+        return string.UTF8String ?: std::string();
+    }
+}
+#endif
+
+std::string Gosu::language()
+{
+    @autoreleasepool {
+        NSString* language = [NSLocale preferredLanguages][0];
+        return language.UTF8String ?: "en";
+    }
+}
+
+#endif

data/src/UtilityWin.cpp

@@ -1,13 +1,16 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_WIN)
+
 #include <Gosu/Utility.hpp>
 #include "WinUtility.hpp"
 #include <windows.h>
-using namespace std;
 
-string Gosu::language()
+std::string Gosu::language()
 {
     LCID lcid = GetUserDefaultLCID();
     char buffer[9];
-    Win::check(
-        GetLocaleInfoA(lcid, LOCALE_SISO639LANGNAME, buffer, sizeof buffer));
+    winapi_check(GetLocaleInfoA(lcid, LOCALE_SISO639LANGNAME, buffer, sizeof buffer));
     return buffer;
 }
+
+#endif

data/src/Version.cpp

@@ -0,0 +1,22 @@
+#include <Gosu/Version.hpp>
+#include <Gosu/Platform.hpp>
+#include <string>
+
+const std::string Gosu::VERSION = std::to_string(GOSU_MAJOR_VERSION) + '.' +
+                                  std::to_string(GOSU_MINOR_VERSION) + '.' +
+                                  std::to_string(GOSU_POINT_VERSION);
+
+const std::string Gosu::LICENSES =
+    "This software may utilize code from the following third-party libraries:\n"
+    "\n"
+    "Gosu, https://www.libgosu.org, MIT License, http://opensource.org/licenses/MIT\n"
+    "SDL 2, http://www.libsdl.org, MIT License, http://opensource.org/licenses/MIT\n"
+#if defined(GOSU_IS_WIN) || defined(GOSU_IS_X)
+    "libsndfile, http://www.mega-nerd.com/libsndfile, GNU LGPL 3, "
+        "http://www.gnu.org/copyleft/lesser.html\n"
+#endif
+#if defined(GOSU_IS_WIN)
+    "OpenAL Soft, http://kcat.strangesoft.net/openal.html, GNU LGPL 2, "
+        "http://www.gnu.org/licenses/old-licenses/lgpl-2.0.html\n"
+#endif
+    ;

data/src/WinMain.cpp

@@ -1,48 +1,45 @@
-#include <windows.h>
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_WIN)
+
 #include <exception>
 #include <string>
 #include <vector>
+#include <windows.h>
 using namespace std;
 
-vector<string> splitCmdLine()
+vector<string> split_cmd_line()
 {
     vector<string> result;
 
-    const char* cmdLine = ::GetCommandLineA();
+    const char* cmd_line = ::GetCommandLineA();
 
-    const char* argBegin = 0;
-    bool isQuotedArg = false;
+    const char* arg_begin = nullptr;
+    bool is_quoted_arg = false;
 
-    while (*cmdLine)
-    {
-        if (*cmdLine == '"')
-        {
-            if (argBegin == 0)
-            {
-                argBegin = cmdLine + 1;
-                isQuotedArg = true;
+    while (*cmd_line) {
+        if (*cmd_line == '"') {
+            if (arg_begin == nullptr) {
+                arg_begin = cmd_line + 1;
+                is_quoted_arg = true;
             }
-            else if (isQuotedArg)
-            {
-                result.push_back(std::string(argBegin, cmdLine));
-                argBegin = 0;
+            else if (is_quoted_arg) {
+                result.push_back(std::string(arg_begin, cmd_line));
+                arg_begin = nullptr;
             }
         }
-        else if (!isspace((unsigned char)*cmdLine) && argBegin == 0)
-        {
-            argBegin = cmdLine;
-            isQuotedArg = false;
+        else if (!isspace((unsigned char)*cmd_line) && arg_begin == nullptr) {
+            arg_begin = cmd_line;
+            is_quoted_arg = false;
         }
-        else if (isspace((unsigned char)*cmdLine) && argBegin != 0 && !isQuotedArg)
-        {
-            result.push_back(std::string(argBegin, cmdLine + 1));
-            argBegin = 0;
+        else if (isspace((unsigned char)*cmd_line) && arg_begin != nullptr && !is_quoted_arg) {
+            result.push_back(std::string(arg_begin, cmd_line + 1));
+            arg_begin = nullptr;
         }
-        ++cmdLine;
+        ++cmd_line;
     }
 
-    if (argBegin != 0)
-        result.push_back(argBegin);
+    if (arg_begin != 0)
+        result.push_back(arg_begin);
 
     return result;
 }
@@ -51,17 +48,17 @@ int main(int argc, char* argv[]);
 
 int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
 {
-    try
-    {
-        vector<string> arguments = splitCmdLine();
+    try {
+        vector<string> arguments = split_cmd_line();
         vector<char*> argv(arguments.size());
         for (unsigned i = 0; i < argv.size(); ++i)
             argv[i] = const_cast<char*>(arguments[i].c_str());
         return main(argv.size(), &argv[0]);
     }
-    catch (const std::exception& e)
-    {
+    catch (const std::exception& e) {
         ::MessageBoxA(0, e.what(), "Uncaught Exception", MB_OK | MB_ICONERROR);
         return EXIT_FAILURE;
     }
 }
+
+#endif