gosu 0.10.9.pre1 → 0.11.0

data/src/Macro.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "GraphicsImpl.hpp"
+#include <Gosu/Fwd.hpp>
+#include <Gosu/ImageData.hpp>
+#include <memory>
+
+class Gosu::Macro : public Gosu::ImageData
+{
+    struct Impl;
+    std::shared_ptr<Impl> pimpl;
+    
+public:
+    Macro(DrawOpQueue& queue, int width, int height);
+    
+    int width() const override;
+    int height() const override;
+    
+    void draw(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) const;
+    
+    const Gosu::GLTexInfo* gl_tex_info() const override;
+    
+    Gosu::Bitmap to_bitmap() const override;
+    
+    std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const override;
+    
+    void insert(const Bitmap& bitmap, int x, int y) override;
+};

data/src/Math.cpp

@@ -1,5 +1,4 @@
 #include <Gosu/Math.hpp>
-#include <cmath>
 #include <cstdlib>
 
 double Gosu::random(double min, double max)
@@ -8,34 +7,32 @@ double Gosu::random(double min, double max)
     return rnd / (static_cast<double>(RAND_MAX) + 1) * (max - min) + min;
 }
 
-double Gosu::offsetX(double angle, double radius)
+double Gosu::offset_x(double angle, double radius)
 {
-    return +std::sin(angle / 180 * pi) * radius;
+    return +std::sin(angle / 180 * M_PI) * radius;
 }
 
-double Gosu::offsetY(double angle, double radius)
+double Gosu::offset_y(double angle, double radius)
 {
-    return -std::cos(angle / 180 * pi) * radius;
+    return -std::cos(angle / 180 * M_PI) * radius;
 }
 
-double Gosu::angle(double fromX, double fromY, double toX, double toY,
-    double def)
+double Gosu::angle(double from_x, double from_y, double to_x, double to_y, double def)
 {
-    double distX = toX - fromX;
-    double distY = toY - fromY;
+    double dist_x = to_x - from_x;
+    double dist_y = to_y - from_y;
 
-    if (distX == 0 && distY == 0)
-        return def;
-    else
-        return normalizeAngle(radiansToGosu(std::atan2(distY, distX)));
+    if (dist_x == 0 && dist_y == 0) return def;
+
+    return normalize_angle(radians_to_gosu(std::atan2(dist_y, dist_x)));
 }
 
-double Gosu::angleDiff(double from, double to)
+double Gosu::angle_diff(double from, double to)
 {
-    return Gosu::normalizeAngle(to - from + 180) - 180;
+    return Gosu::normalize_angle(to - from + 180) - 180;
 }
 
-double Gosu::normalizeAngle(double angle)
+double Gosu::normalize_angle(double angle)
 {
     return wrap(angle, 0.0, 360.0);
 }
@@ -43,31 +40,22 @@ double Gosu::normalizeAngle(double angle)
 int Gosu::wrap(int value, int min, int max)
 {
     int result = (value - min) % (max - min);
-    if (result < 0)
-        return result + max;
-    else
-        return result + min;
+    return result < 0 ? result + max : result + min;
 }
 
 float Gosu::wrap(float value, float min, float max)
 {
     double result = std::fmod(value - min, max - min);
-    if (result < 0)
-        return result + max;
-    else
-        return result + min;
+    return result < 0 ? result + max : result + min;
 }
 
 double Gosu::wrap(double value, double min, double max)
 {
     double result = std::fmod(value - min, max - min);
-    if (result < 0)
-        return result + max;
-    else
-        return result + min;
+    return result < 0 ? result + max : result + min;
 }
 
 double Gosu::distance(double x1, double y1, double x2, double y2)
 {
-    return std::sqrt(distanceSqr(x1, y1, x2, y2));
+    return std::sqrt(distance_sqr(x1, y1, x2, y2));
 }

data/src/{Audio/OggFile.hpp → OggFile.hpp}

@@ -1,14 +1,13 @@
-#ifndef GOSU_SRC_AUDIO_OGGFILE_HPP
-#define GOSU_SRC_AUDIO_OGGFILE_HPP
+#pragma once
 
 #include "AudioFile.hpp"
 #include <Gosu/IO.hpp>
 #include <algorithm>
 #include <stdexcept>
-#include <sstream>
+#include <string>
 
 #define STB_VORBIS_HEADER_ONLY
-#include "../stb_vorbis.c"
+#include "stb_vorbis.c"
 
 // Based on the Drama Sound Engine for D
 
@@ -19,26 +18,24 @@ namespace Gosu
         Gosu::Buffer contents_;
         Gosu::Buffer buffer_;
         int channels_;
-        ALenum sampleRate_;
+        ALenum sample_rate_;
         stb_vorbis* stream_;
 
         void open()
         {
             int error = 0;
             
-            const unsigned char *mem = static_cast<const unsigned char*>(contents_.data());
+            const unsigned char* mem = static_cast<const unsigned char*>(contents_.data());
             stream_ = stb_vorbis_open_memory(mem, contents_.size(), &error, 0);
             
-            if (stream_ == 0)
-            {
-                std::ostringstream message;
-                message << "Cannot open Ogg Vorbis file, error code: " << error;
-                throw std::runtime_error(message.str());
+            if (stream_ == 0) {
+                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;
-            sampleRate_ = info.sample_rate;
+            sample_rate_ = info.sample_rate;
             buffer_.resize(info.temp_memory_required);
         }
         
@@ -67,25 +64,25 @@ namespace Gosu
             return (channels_ == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16);
         }
         
-        ALuint sampleRate() const
+        ALuint sample_rate() const
         {
-            return sampleRate_;
+            return sample_rate_;
         }
         
-        std::size_t readData(void* dest, std::size_t length)
+        std::size_t read_data(void* dest, std::size_t length)
         {
             int samples = 0;
-            int maxSamples = length / sizeof(short);
+            int max_samples = length / sizeof(short);
             
-            while (samples < maxSamples) {
-                int samplesPerChannel =
+            while (samples < max_samples) {
+                int samples_per_channel =
                     stb_vorbis_get_samples_short_interleaved(stream_, channels_,
-                        static_cast<short*>(dest) + samples, maxSamples - samples);
+                                                             static_cast<short*>(dest) + samples,
+                                                             max_samples - samples);
                 
-                if (samplesPerChannel == 0)
-                    break;
+                if (samples_per_channel == 0) break;
                 
-                samples += samplesPerChannel * channels_;
+                samples += samples_per_channel * channels_;
             }
             
             return samples * sizeof(short);
@@ -97,5 +94,3 @@ namespace Gosu
         }
     };
 }
-
-#endif

data/src/RenderState.hpp

@@ -0,0 +1,205 @@
+#pragma once
+
+#include "GraphicsImpl.hpp"
+#include "Texture.hpp"
+
+// Properties that potentially need to be changed between each draw operation.
+// This does not include the color or vertex data of the actual quads.
+struct Gosu::RenderState
+{
+    std::shared_ptr<Texture> texture;
+    const Transform* transform;
+    ClipRect clip_rect;
+    AlphaMode mode;
+    
+    RenderState()
+    : transform(0), mode(AM_DEFAULT)
+    {
+        clip_rect.width = NO_CLIPPING;
+    }
+    
+    bool operator==(const RenderState& rhs) const
+    {
+        return texture == rhs.texture &&
+            transform == rhs.transform &&
+            clip_rect == rhs.clip_rect &&
+            mode == rhs.mode;
+    }
+    
+    void apply_texture() const
+    {
+        if (texture) {
+            glEnable(GL_TEXTURE_2D);
+            glBindTexture(GL_TEXTURE_2D, texture->tex_name());
+        }
+        else {
+            glDisable(GL_TEXTURE_2D);
+        }
+    }
+    
+    void apply_alpha_mode() const
+    {
+        if (mode == AM_ADD) {
+            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+        }
+        else if (mode == AM_MULTIPLY) {
+            glBlendFunc(GL_DST_COLOR, GL_ZERO);
+        }
+        else {
+            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        }
+    }
+    
+    void apply_clip_rect() const
+    {
+        if (clip_rect.width == NO_CLIPPING) {
+            glDisable(GL_SCISSOR_TEST);
+        }
+        else {
+            glEnable(GL_SCISSOR_TEST);
+            glScissor(clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height);
+        }
+    }
+    
+    // Only used by Macro so far
+    #ifndef GOSU_IS_OPENGLES
+    void apply() const
+    {
+        apply_texture();
+        // TODO: No inner clip_rect yet - how would this work?!
+        apply_alpha_mode();
+    }
+    #endif
+};
+
+// Manages the OpenGL rendering state. It caches the current state, only forwarding the
+// changes to OpenGL if the new state is really different.
+class Gosu::RenderStateManager : private Gosu::RenderState
+{
+    // Not copyable
+    RenderStateManager(const RenderStateManager&);
+    RenderStateManager& operator=(const RenderStateManager&);
+    
+    void apply_transform() const
+    {
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+        
+        #ifndef GOSU_IS_OPENGLES
+        glMultMatrixd(&(*transform)[0]);
+        #else
+        // TODO: Ouch, should always use floats!
+        GLfloat matrix[16];
+        for (int i = 0; i < 16; ++i) {
+            matrix[i] = (*transform)[i];
+        }
+        glMultMatrixf(matrix);
+        #endif
+    }
+    
+public:
+    RenderStateManager()
+    {
+        apply_alpha_mode();
+        // Preserve previous MV matrix
+        glMatrixMode(GL_MODELVIEW);
+        glPushMatrix();
+    }
+    
+    ~RenderStateManager()
+    {
+        ClipRect no_clipping;
+        no_clipping.width = NO_CLIPPING;
+        set_clip_rect(no_clipping);
+        set_texture(std::shared_ptr<Texture>());
+        // Return to previous MV matrix
+        glMatrixMode(GL_MODELVIEW);
+        glPopMatrix();
+    }
+    
+    void set_render_state(const RenderState& rs)
+    {
+        set_texture(rs.texture);
+        set_transform(rs.transform);
+        set_clip_rect(rs.clip_rect);
+        set_alpha_mode(rs.mode);
+    }
+    
+    void set_texture(std::shared_ptr<Texture> new_texture)
+    {
+        if (new_texture == texture) return;
+
+        if (new_texture) {
+            // New texture *is* really a texture - change to it.
+            
+            if (!texture) {
+                glEnable(GL_TEXTURE_2D);
+            }
+            glBindTexture(GL_TEXTURE_2D, new_texture->tex_name());
+        }
+        else {
+            // New texture is NO_TEXTURE, disable texturing.
+            glDisable(GL_TEXTURE_2D);
+        }
+        texture = new_texture;
+    }
+    
+    void set_transform(const Transform* new_transform)
+    {
+        if (new_transform == transform) return;
+        
+        transform = new_transform;
+        apply_transform();
+    }
+
+    void set_clip_rect(const ClipRect& new_clip_rect)
+    {
+        if (new_clip_rect.width == NO_CLIPPING) {
+            // Disable clipping
+            if (clip_rect.width != NO_CLIPPING) {
+                glDisable(GL_SCISSOR_TEST);
+                clip_rect.width = NO_CLIPPING;
+            }
+        }
+        else {
+            // Enable clipping if off
+            if (clip_rect.width == NO_CLIPPING) {
+                glEnable(GL_SCISSOR_TEST);
+                clip_rect = new_clip_rect;
+                glScissor(clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height);
+            }
+            // Adjust clipping if necessary
+            else if (!(clip_rect == new_clip_rect)) {
+                clip_rect = new_clip_rect;
+                glScissor(clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height);
+            }
+        }
+    }
+    
+    void set_alpha_mode(AlphaMode new_mode)
+    {
+        if (new_mode == mode) return;
+        
+        mode = new_mode;
+        apply_alpha_mode();
+    }
+    
+    // The cached values may have been messed with. Reset them again.
+    void enforce_after_untrusted_gL() const
+    {
+        apply_texture();
+        apply_transform();
+        apply_clip_rect();
+        apply_alpha_mode();
+    }
+};
+
+namespace Gosu
+{
+    struct VertexArray
+    {
+        RenderState render_state;
+        std::vector<ArrayVertex> vertices;
+    };
+    typedef std::list<VertexArray> VertexArrays;
+}

data/src/Resolution.cpp

@@ -0,0 +1,86 @@
+#include <Gosu/Gosu.hpp>
+
+#ifdef GOSU_IS_WIN
+#include <windows.h>
+
+// On Windows, do not use the SDL 2 code below. It reports 2560x1920 in my Windows VM, which is
+// running at 2560x1080. (SDL 2.0.3)
+
+unsigned Gosu::screen_width()
+{
+    return GetSystemMetrics(SM_CXSCREEN);
+}
+
+unsigned Gosu::screen_height()
+{
+    return GetSystemMetrics(SM_CYSCREEN);
+}
+
+static SIZE calculate_available_size()
+{
+    RECT work_area;
+    SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0);
+    
+    RECT window_size = work_area;
+    // Note: This should be kept in sync with STYLE_NORMAL in SDL_windowswindow.c.
+    DWORD style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
+    AdjustWindowRectEx(&window_size, style, FALSE, 0);
+    
+    SIZE size;
+    size.cx = 2 * (work_area.right - work_area.left) - (window_size.right - window_size.left);
+    size.cy = 2 * (work_area.bottom - work_area.top) - (window_size.bottom - window_size.top);
+    return size;
+}
+
+static SIZE available_size = calculate_available_size();
+
+unsigned Gosu::available_width()
+{
+    return available_size.cx;
+}
+
+unsigned Gosu::available_height()
+{
+    return available_size.cy;
+}
+#elif !defined(GOSU_IS_IPHONE)
+#include <SDL.h>
+
+static SDL_DisplayMode current_display_mode = { 0, 0 };
+
+unsigned Gosu::screen_width()
+{
+    // TODO - not thread-safe
+    if (current_display_mode.w == 0) {
+        SDL_Init(SDL_INIT_VIDEO);
+        SDL_GetDisplayMode(0, 0, &current_display_mode);
+        SDL_QuitSubSystem(SDL_INIT_VIDEO);
+    }
+    return current_display_mode.w;
+}
+
+unsigned Gosu::screen_height()
+{
+    // TODO - not thread-safe
+    if (current_display_mode.h == 0) {
+        SDL_Init(SDL_INIT_VIDEO);
+        SDL_GetDisplayMode(0, 0, &current_display_mode);
+        SDL_QuitSubSystem(SDL_INIT_VIDEO);
+    }
+    return current_display_mode.h;
+}
+
+// Pessimistic fallback implementation for available_width / available_height.
+
+#if !defined(GOSU_IS_MAC)
+unsigned Gosu::available_width()
+{
+    return Gosu::screen_width() * 0.9;
+}
+
+unsigned Gosu::available_height()
+{
+    return Gosu::screen_height() * 0.8;
+}
+#endif
+#endif