gosu 0.10.9.pre1 → 0.11.0

data/Gosu/Graphics.hpp

@@ -1,13 +1,12 @@
 //! \file Graphics.hpp
 //! Interface of the Graphics class.
 
-#ifndef GOSU_GRAPHICS_HPP
-#define GOSU_GRAPHICS_HPP
+#pragma once
 
 #include <Gosu/Fwd.hpp>
 #include <Gosu/Color.hpp>
 #include <Gosu/GraphicsBase.hpp>
-#include <Gosu/TR1.hpp>
+#include <functional>
 #include <memory>
 
 namespace Gosu
@@ -17,44 +16,30 @@ namespace Gosu
     //! Returns the maximum size of an texture that will be allocated
     //! internally by Gosu.
     //! Useful when extending Gosu using OpenGL.
-    unsigned const MAX_TEXTURE_SIZE = 1024;
+    const unsigned MAX_TEXTURE_SIZE = 1024;
     
     //! Serves as the target of all drawing and provides primitive drawing
     //! functionality.
     //! Usually created internally by Gosu::Window.
-    //
-    // TODO: This class should be separated into a Gosu::Viewport class, which
-    // carries the width/height/fullscreen attributes, and global Gosu::drawFoo
-    // functions. A Window then has a Viewport, and in theory, multiple windows
-    // could have their own viewports etc.
     class Graphics
     {
         struct Impl;
+        // Non-movable (const) to avoid dangling internal references.
+        const std::unique_ptr<Impl> pimpl;
         
-        const GOSU_UNIQUE_PTR<Impl> pimpl;
-        
-    #if defined(GOSU_CPP11_ENABLED)
-        // explicitly forbid copying and moving
-        Graphics(Graphics&&) = delete;
-        Graphics& operator=(Graphics&&) = delete;
-        Graphics(const Graphics&) = delete;
-        Graphics& operator=(const Graphics&) = delete;
-    #endif
-
     public:
-        Graphics(unsigned physicalWidth, unsigned physicalHeight, bool fullscreen);
+        Graphics(unsigned physical_width, unsigned physical_height);
         ~Graphics();
 
-        void setResolution(unsigned logicalWidth, unsigned logicalHeight,
-            double horizontalBlackBarWidth = 0, double verticalBlackBarHeight = 0);
+        void set_resolution(unsigned logical_width, unsigned logical_height,
+            double horizontal_black_bar_width = 0, double vertical_black_bar_height = 0);
         
         unsigned width() const;
         unsigned height() const;
-        bool fullscreen() const;
 
         //! Prepares the graphics object for drawing. Nothing must be drawn
         //! without calling begin.
-        bool begin(Color clearWithColor = Color::BLACK);
+        bool begin(Color clear_with_color = Color::BLACK);
         //! Every call to begin must have a matching call to end.
         void end();
         
@@ -64,65 +49,63 @@ namespace Gosu
         
         //! Finishes all pending Gosu drawing operations and executes
         //! the following OpenGL code in a clean environment.
-        static void beginGL();
+        static void begin_gl();
         //! Resets Gosu into its default rendering state.
-        static void endGL();
+        static void end_gl();
         //! Schedules a custom GL functor to be executed at a certain Z level.
-        //! The functor is called in a clean GL context (as given by beginGL/endGL).
+        //! The functor is called in a clean GL context (as given by begin_gl/end_gl).
         //! Gosu's rendering up to the Z level may not yet have been glFlush()ed.
         //! Note: You may not call any Gosu rendering functions from within the
         //! functor, and you must schedule it from within Window::draw's call tree.
-        static void scheduleGL(const std::tr1::function<void()>& functor, ZPos z);
+        static void gl(const std::function<void ()>& functor, ZPos z);
         
         //! Enables clipping to a specified rectangle.
-        static void beginClipping(double x, double y, double width, double height);
+        static void begin_clipping(double x, double y, double width, double height);
         //! Disables clipping.
-        static void endClipping();
+        static void end_clipping();
         
         //! Starts recording a macro. Cannot be nested.
-        static void beginRecording();
+        static void begin_recording();
         //! Finishes building the macro and returns it as a drawable object.
         //! The width and height affect nothing about the recording process,
         //! the resulting macro will simply return these values when you ask
         //! it.
         //! Most usually, the return value is passed to Image::Image().
-        static GOSU_UNIQUE_PTR<Gosu::ImageData> endRecording(int width, int height);
+        static std::unique_ptr<Gosu::ImageData> end_recording(int width, int height);
         
         //! Pushes one transformation onto the transformation stack.
-        static void pushTransform(const Transform& transform);
+        static void push_transform(const Transform& transform);
         //! Pops one transformation from the transformation stack.
-        static void popTransform();
+        static void pop_transform();
 
         //! Draws a line from one point to another (last pixel exclusive).
         //! Note: OpenGL lines are not reliable at all and may have a missing pixel at the start
         //! or end point. Please only use this for debugging purposes. Otherwise, use a quad or
-        //! image to simulate lines, or contribute a better drawLine to Gosu.
-        static void drawLine(double x1, double y1, Color c1,
+        //! image to simulate lines, or contribute a better draw_line to Gosu.
+        static void draw_line(double x1, double y1, Color c1,
             double x2, double y2, Color c2,
-            ZPos z, AlphaMode mode = amDefault);
+            ZPos z, AlphaMode mode = AM_DEFAULT);
 
-        static void drawTriangle(double x1, double y1, Color c1,
+        static void draw_triangle(double x1, double y1, Color c1,
             double x2, double y2, Color c2,
             double x3, double y3, Color c3,
-            ZPos z, AlphaMode mode = amDefault);
+            ZPos z, AlphaMode mode = AM_DEFAULT);
 
-        static void drawQuad(double x1, double y1, Color c1,
+        static void draw_quad(double x1, double y1, Color c1,
             double x2, double y2, Color c2,
             double x3, double y3, Color c3,
             double x4, double y4, Color c4,
-            ZPos z, AlphaMode mode = amDefault);
+            ZPos z, AlphaMode mode = AM_DEFAULT);
 
         //! For internal use only.
-        void setPhysicalResolution(unsigned physicalWidth, unsigned physicalHeight);
+        void set_physical_resolution(unsigned physical_width, unsigned physical_height);
 
         //! For internal use only.
-        static void scheduleDrawOp(const DrawOp& op);
+        static void schedule_draw_op(const DrawOp& op);
 
         //! Turns a portion of a bitmap into something that can be drawn on a Graphics object.
-        static GOSU_UNIQUE_PTR<ImageData> createImage(const Bitmap& src,
-            unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
-            unsigned imageFlags);
+        static std::unique_ptr<ImageData> create_image(const Bitmap& src,
+            unsigned src_x, unsigned src_y, unsigned src_width, unsigned src_height,
+            unsigned image_flags);
     };
 }
-
-#endif

data/Gosu/GraphicsBase.hpp

@@ -1,104 +1,73 @@
 //! \file GraphicsBase.hpp
 //! Contains general typedefs and enums related to graphics.
 
-#ifndef GOSU_GRAPHICSBASE_HPP
-#define GOSU_GRAPHICSBASE_HPP
+#pragma once
 
 #include <Gosu/Platform.hpp>
-#include <Gosu/TR1.hpp>
-#include <limits>
+#include <array>
 
 namespace Gosu
 {
     //! Represents the Z position of something drawn with Gosu's graphics
     //! system. Draw calls with higher ZPos values will cover those with a
-    //! lower ZPos value, that is, they are performed last.
+    //! lower ZPos value.
     typedef double ZPos;
     
     //! Determines the way colors are combined when one is drawn onto
     //! another.
-#if defined(GOSU_CPP11_ENABLED)
-    enum class AlphaMode
-    {
-        //! The color's channels will be interpolated. The alpha channel
-        //! specifies the opacity of the new color, 255 is full opacity.
-        DEFAULT,
-        INTERPOLATE = DEFAULT,
-        //! The colors' channels will be added. The alpha channel specifies
-        //! the percentage of the new color's channels that will be added
-        //! to the old color's channels.
-        ADD,
-        //! The color's channels will be multiplied with each other.
-        MULTIPLY
-    };
-    constexpr AlphaMode amDefault = AlphaMode::DEFAULT;
-    constexpr AlphaMode amInterpolate = AlphaMode::INTERPOLATE;
-    constexpr AlphaMode amAdd = AlphaMode::ADD;
-    constexpr AlphaMode amAdditive = AlphaMode::ADD;
-    constexpr AlphaMode amMultiply = AlphaMode::MULTIPLY;
-#else
     enum AlphaMode
     {
+        AM_DEFAULT,
         //! The color's channels will be interpolated. The alpha channel
         //! specifies the opacity of the new color, 255 is full opacity.
-        amDefault,
+        AM_INTERPOLATE = AM_DEFAULT,
         //! The colors' channels will be added. The alpha channel specifies
         //! the percentage of the new color's channels that will be added
         //! to the old color's channels.
-        amAdd,
-        amAdditive = amAdd,
+        AM_ADD,
         //! The color's channels will be multiplied with each other.
-        amMultiply
+        AM_MULTIPLY
     };
-#endif
     
     enum FontFlags
     {
-        ffBold         = 1,
-        ffItalic       = 2,
-        ffUnderline    = 4,
-        ffCombinations = 8
+        FF_BOLD         = 1,
+        FF_ITALIC       = 2,
+        FF_UNDERLINE    = 4,
+        FF_COMBINATIONS = 8
     };
     
-    enum TextAlign
+    enum Alignment
     {
-        taLeft,
-        taRight,
-        taCenter,
-        taJustify
+        AL_LEFT,
+        AL_RIGHT,
+        AL_CENTER,
+        AL_JUSTIFY
     };
     
     //! Flags that affect the tileability or interpolation of an image.
     enum ImageFlags
     {
-        ifSmooth = 0,
+        IF_SMOOTH = 0,
         
-        // Note: No constant for '1', but Gosu treats '1' as ifTileable for
+        // Note: No constant for '1', but Gosu treats '1' as if_tileable for
         // backward compatibility reasons (this parameter used to be a bool).
         
-        ifTileableLeft   = 1 << 1,
-        ifTileableTop    = 1 << 2,
-        ifTileableRight  = 1 << 3,
-        ifTileableBottom = 1 << 4,
-        ifTileable       = ifTileableLeft | ifTileableTop | ifTileableRight | ifTileableBottom,
+        IF_TILEABLE_LEFT   = 1 << 1,
+        IF_TILEABLE_TOP    = 1 << 2,
+        IF_TILEABLE_RIGHT  = 1 << 3,
+        IF_TILEABLE_BOTTOM = 1 << 4,
+        IF_TILEABLE        = IF_TILEABLE_LEFT | IF_TILEABLE_TOP | IF_TILEABLE_RIGHT | IF_TILEABLE_BOTTOM,
         
         //! Apply nearest-neighbor interpolation when scaling this image up or
         //! down.
-        ifRetro          = 1 << 5
+        IF_RETRO           = 1 << 5
     };
     
-    typedef std::tr1::array<double, 16> Transform;
+    typedef std::array<double, 16> Transform;
     Transform translate(double x, double y);
-    Transform rotate(double angle, double aroundX = 0, double aroundY = 0);
+    Transform rotate(double angle, double around_x = 0, double around_y = 0);
     Transform scale(double factor);
-    Transform scale(double factorX, double factorY, double fromX = 0, double fromY = 0);
+    Transform scale(double scale_x, double scale_y, double from_x = 0, double from_y = 0);
     Transform concat(const Transform& lhs, const Transform& rhs);
-    
-#ifndef SWIG
-    // A not so useful optimization - this was supposed to bypass the Z queue for immediate rendering.
-    // In retrospect, the only useful optimization would be to work down the Z queue on a second thread.
-    GOSU_DEPRECATED const double zImmediate = -std::numeric_limits<double>::infinity();
-#endif
 }
-
-#endif

data/Gosu/IO.hpp

@@ -1,25 +1,24 @@
 //! \file IO.hpp
 //! Contains everything related to input and output.
 
-#ifndef GOSU_IO_HPP
-#define GOSU_IO_HPP
+#pragma once
 
-#include <cstddef>
+#include <Gosu/Platform.hpp>
 #include <algorithm>
+#include <cstddef>
 #include <memory>
 #include <string>
 #include <vector>
-#include <Gosu/Platform.hpp>
 
 namespace Gosu
 {
     class Resource;
     
-    enum ByteOrder { boLittle, boBig, boDontCare };
+    enum ByteOrder { BO_LITTLE, BO_BIG, BO_DONT_CARE };
 #ifdef __BIG_ENDIAN__
-    const ByteOrder nativeByteOrder = boBig, otherByteOrder = boLittle;
+    const ByteOrder BO_NATIVE = BO_BIG, BO_OTHER = BO_LITTLE;
 #else
-    const ByteOrder nativeByteOrder = boLittle, otherByteOrder = boBig;
+    const ByteOrder BO_NATIVE = BO_LITTLE, BO_OTHER = BO_BIG;
 #endif
 
     //! Utility class that points to a specific position in a resource
@@ -45,7 +44,7 @@ namespace Gosu
             return pos;
         }
 
-        void setPosition(std::size_t value)
+        void set_position(std::size_t value)
         {
             // TODO: Check?
             pos = value;
@@ -57,26 +56,25 @@ namespace Gosu
             pos += offset;
         }
 
-        void read(void* destBuffer, std::size_t length);
+        void read(void* dest_buffer, std::size_t length);
         
         //! Convenience function; equivalent to read(&t, sizeof t).
         template<typename T>
-        void readPod(T& t, ByteOrder bo = boDontCare)
+        void read_pod(T& t, ByteOrder bo = BO_DONT_CARE)
         {
             read(&t, sizeof t);
-            if (bo == otherByteOrder)
-            {
+            if (bo == BO_OTHER) {
                 char* begin = reinterpret_cast<char*>(&t);
                 std::reverse(begin, begin + sizeof t);
             }
         }
 
-        //! Similar to readPod(T&), but returns the read value instead.
+        //! Similar to read_pod(T&), but returns the read value instead.
         template<typename T>
-        T getPod(ByteOrder bo = boDontCare)
+        T get_pod(ByteOrder bo = BO_DONT_CARE)
         {
             T t;
-            readPod<T>(t, bo);
+            read_pod<T>(t, bo);
             return t;
         }
     };
@@ -104,7 +102,7 @@ namespace Gosu
             return pos;
         }
 
-        void setPosition(std::size_t value)
+        void set_position(std::size_t value)
         {
             // TODO: Check?
             pos = value;
@@ -116,21 +114,21 @@ namespace Gosu
             pos += offset;
         }
 
-        void write(const void* sourceBuffer, std::size_t length);
+        void write(const void* source_buffer, std::size_t length);
 
         //! Convenience function; equivalent to write(&t, sizeof t).
         template<typename T>
-        void writePod(const T& t, ByteOrder bo = boDontCare)
+        void write_pod(const T& t, ByteOrder bo = BO_DONT_CARE)
         {
-            if (bo == otherByteOrder)
-            {
+            if (bo == BO_OTHER) {
                 char buf[sizeof t];
                 const char* begin = reinterpret_cast<const char*>(&t);
                 std::reverse_copy(begin, begin + sizeof t, buf);
                 write(buf, sizeof buf);
             }
-            else
+            else {
                 write(&t, sizeof t);
+            }
         }
     };
 
@@ -141,17 +139,11 @@ namespace Gosu
     //! truncating its content or allocating room for more data.
     class Resource
     {
-        // Non-copyable
-#if defined(GOSU_CPP11_ENABLED)
+        // Non-copyable and non-movable to avoid slicing.
         Resource(const Resource&) = delete;
         Resource& operator=(const Resource&) = delete;
-        // and non-movable
         Resource(Resource&&) = delete;
         Resource& operator=(Resource&&) = delete;
-#else
-        Resource(const Resource&);
-        Resource& operator=(const Resource&);
-#endif
 
     public:
         Resource()
@@ -164,27 +156,25 @@ namespace Gosu
 
         //! Convenience: Creates a new Reader that reads from the start of
         //! the resource.
-        Reader frontReader() const
+        Reader front_reader() const
         {
             return Reader(*this, 0);
         }
 
         //! Convenience: Creates a new Writer that appends data at the
         //! end of the resource.
-        Writer backWriter()
+        Writer back_writer()
         {
             return Writer(*this, size());
         }
 
         virtual std::size_t size() const = 0;
 
-        virtual void resize(std::size_t newSize) = 0;
+        virtual void resize(std::size_t new_size) = 0;
 
-        virtual void read(std::size_t offset, std::size_t length,
-            void* destBuffer) const = 0;
+        virtual void read(std::size_t offset, std::size_t length, void* dest_buffer) const = 0;
 
-        virtual void write(std::size_t offset, std::size_t length,
-            const void* sourceBuffer) = 0;
+        virtual void write(std::size_t offset, std::size_t length, const void* source_buffer) = 0;
     };
 
     //! Piece of memory with the Resource interface.
@@ -209,14 +199,13 @@ namespace Gosu
             return *this;
         }
 
-        std::size_t size() const;
-        void resize(std::size_t newSize);
+        std::size_t size() const override;
 
-        void read(std::size_t offset, std::size_t length,
-            void* destBuffer) const;
+        void resize(std::size_t new_size) override;
 
-        void write(std::size_t offset, std::size_t length,
-            const void* sourceBuffer);
+        void read(std::size_t offset, std::size_t length, void* dest_buffer) const override;
+        
+        void write(std::size_t offset, std::size_t length, const void* source_buffer) override;
 
         const void* data() const
         {
@@ -233,37 +222,36 @@ namespace Gosu
     {
         //! Opens an existing file for reading; throws an exception if the file
         //! cannot be found.
-        fmRead,
+        FM_READ,
         //! Writes data to a file. If the file already exists, is emptied on
         //! opening. If the file does not exist, it is created.
-        fmReplace,
+        FM_REPLACE,
         //! Opens or creates a file with writing access, but does not clear
         //! existing contents.
-        fmAlter
+        FM_ALTER
     };
 
     //! File with the Resource interface.
     class File : public Resource
     {
         struct Impl;
-        const GOSU_UNIQUE_PTR<Impl> pimpl;
+        const std::unique_ptr<Impl> pimpl;
 
     public:
-        explicit File(const std::wstring& filename, FileMode mode = fmRead);
+        explicit File(const std::string& filename, FileMode mode = FM_READ);
         ~File();
 
-        std::size_t size() const;
-        void resize(std::size_t newSize);
-        void read(std::size_t offset, std::size_t length,
-            void* destBuffer) const;
-        void write(std::size_t offset, std::size_t length,
-            const void* sourceBuffer);
+        std::size_t size() const override;
+        
+        void resize(std::size_t new_size) override;
+        
+        void read(std::size_t offset, std::size_t length, void* dest_buffer) const override;
+        
+        void write(std::size_t offset, std::size_t length, const void* source_buffer) override;
     };
 
     //! Loads a whole file into a buffer.
-    void loadFile(Buffer& buffer, const std::wstring& filename);
+    void load_file(Buffer& buffer, const std::string& filename);
     //! Creates or overwrites a file with the contents of a buffer.
-    void saveFile(const Buffer& buffer, const std::wstring& filename);
+    void save_file(const Buffer& buffer, const std::string& filename);
 }
-
-#endif