gosu 0.10.9.pre1 → 0.11.0

data/src/DirectoriesUnix.cpp

@@ -1,41 +1,43 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_X)
+
 #include <Gosu/Directories.hpp>
 #include <Gosu/Utility.hpp>
 #include <cassert>
+#include <pwd.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <pwd.h>
 
-namespace 
+static std::string home_dir()
 {
-    std::wstring homeDir()
-    {   
-        passwd* pwd = getpwuid(geteuid());
-        assert(pwd);
-        return Gosu::widen(pwd->pw_dir);
-    }
+    passwd* pwd = getpwuid(geteuid());
+    assert (pwd && pwd->pw_dir);
+    return pwd->pw_dir;
 }
 
-void Gosu::useResourceDirectory()
+void Gosu::use_resource_directory()
 {
-    // Do nothing - the current directory HAS to be correct on Linux.
+    // Do nothing, we expect the user to have the correct cwd on Linux.
 }
 
-std::wstring Gosu::resourcePrefix()
+std::string Gosu::resource_prefix()
 {
-    return std::wstring();
+    return std::string();
 }
 
-std::wstring Gosu::sharedResourcePrefix()
+std::string Gosu::shared_resource_prefix()
 {
-    return std::wstring();
+    return std::string();
 }
 
-std::wstring Gosu::userSettingsPrefix()
+std::string Gosu::user_settings_prefix()
 {
-    return homeDir() + L"/.";
+    return home_dir() + "/.";
 }
 
-std::wstring Gosu::userDocsPrefix()
+std::string Gosu::user_documents_prefix()
 {
-    return homeDir() + L"/";
+    return home_dir() + "/";
 }
+
+#endif

data/src/DirectoriesWin.cpp

@@ -1,69 +1,68 @@
-#include <Gosu/Directories.hpp>
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_WIN)
+
 #include "WinUtility.hpp"
+#include <Gosu/Directories.hpp>
+#include <Gosu/Utility.hpp>
 #include <cwchar>
 #include <stdexcept>
 #include <shlobj.h>
 
-namespace
+static std::string special_folder_path(int csidl)
 {
-    std::wstring specialFolderPath(int csidl)
-    {
-        WCHAR buf[MAX_PATH + 2];
-        if (FAILED(SHGetFolderPath(NULL, csidl | CSIDL_FLAG_CREATE, NULL, 0, buf)))
-            throw std::runtime_error("Error getting special folder path");
-        std::size_t len = std::wcslen(buf);
-        if (buf[len - 1] != L'\\')
-        {
-            buf[len] = L'\\';
-            buf[len + 1] = 0;
-        }
-        return buf;
+    WCHAR buf[MAX_PATH + 2];
+    if (FAILED(SHGetFolderPathW(nullptr, csidl | CSIDL_FLAG_CREATE, nullptr, 0, buf))) {
+        throw std::runtime_error("Error getting special folder path");
     }
+    std::size_t len = std::wcslen(buf);
+    if (buf[len - 1] != L'\\') {
+        buf[len] = L'\\';
+        buf[len + 1] = 0;
+    }
+    return Gosu::wstring_to_utf8(buf);
+}
 
-    std::wstring exeFilename()
-    {
-        static std::wstring result;
-        if (!result.empty())
-            return result;
-
-        wchar_t buffer[MAX_PATH * 2];
-        Gosu::Win::check(::GetModuleFileName(0, buffer, MAX_PATH * 2),
-            "getting the module filename");
-        result = buffer;
-        return result;
+static std::string exe_filename()
+{
+    static std::string result;
+    if (result.empty()) {
+        WCHAR buffer[MAX_PATH * 2];
+        Gosu::winapi_check(GetModuleFileNameW(nullptr, buffer, MAX_PATH * 2),
+                           "getting the module filename");
+        result = Gosu::wstring_to_utf8(buffer);
     }
+    return result;
 }
 
-void Gosu::useResourceDirectory()
+void Gosu::use_resource_directory()
 {
-    SetCurrentDirectory(resourcePrefix().c_str());
+    SetCurrentDirectory(utf8_to_wstring(resource_prefix()).c_str());
 }
 
-std::wstring Gosu::resourcePrefix()
+std::string Gosu::resource_prefix()
 {
-    static std::wstring result;
+    static std::string result;
     if (result.empty()) {
-        result = exeFilename();
-        std::wstring::size_type lastDelim = result.find_last_of(L"\\/");
-        if (lastDelim != std::wstring::npos)
-            result.resize(lastDelim + 1);
-        else
-            result = L"";
+        result = exe_filename();
+        auto last_delim = result.find_last_of("\\/");
+        result.resize(last_delim == result.npos ? 0 : last_delim + 1);
     }
     return result;
 }
 
-std::wstring Gosu::sharedResourcePrefix()
+std::string Gosu::shared_resource_prefix()
 {
-    return resourcePrefix();
+    return resource_prefix();
 }
 
-std::wstring Gosu::userSettingsPrefix()
+std::string Gosu::user_settings_prefix()
 {
-    return specialFolderPath(CSIDL_APPDATA);
+    return special_folder_path(CSIDL_APPDATA);
 }
 
-std::wstring Gosu::userDocsPrefix()
+std::string Gosu::user_documents_prefix()
 {
-    return specialFolderPath(CSIDL_PERSONAL);
+    return special_folder_path(CSIDL_PERSONAL);
 }
+
+#endif

data/src/DrawOp.hpp

@@ -0,0 +1,168 @@
+#pragma once
+
+#include "GraphicsImpl.hpp"
+#include "RenderState.hpp"
+#include "TexChunk.hpp"
+#include <Gosu/Color.hpp>
+#include <Gosu/GraphicsBase.hpp>
+#include <cassert>
+
+namespace Gosu
+{
+    struct DrawOp
+    {
+        // For sorting before drawing the queue.
+        ZPos z;
+        
+        RenderState render_state;
+        // Only valid if render_state.tex_name != NO_TEXTURE
+        GLfloat top, left, bottom, right;
+        
+        // TODO: Merge with Gosu::ArrayVertex.
+        struct Vertex
+        {
+            float x, y;
+            Color c;
+            Vertex() {}
+            Vertex(float x, float y, Color c) : x(x), y(y), c(c) {}
+        };
+        Vertex vertices[4];
+        
+        // Number of vertices used, or: complement index of code block
+        int vertices_or_block_index;
+        
+        void perform(const DrawOp* next) const
+        {
+            // This should not be called on GL code ops.
+            assert (vertices_or_block_index >= 2);
+            assert (vertices_or_block_index <= 4);
+            
+            #ifdef GOSU_IS_OPENGLES
+            static const unsigned MAX_AUTOGROUP = 24;
+            
+            static int sprite_counter = 0;
+            static float sprite_vertices[12 * MAX_AUTOGROUP];
+            static float sprite_texcoords[12 * MAX_AUTOGROUP];
+            static unsigned sprite_colors[6 * MAX_AUTOGROUP];
+            
+            // iPhone specific setup
+            static bool is_setup = false;
+            if (!is_setup) {
+                // Sets up pointers and enables states needed for using vertex arrays and textures
+                glVertexPointer(2, GL_FLOAT, 0, sprite_vertices);
+                glEnableClientState(GL_VERTEX_ARRAY);
+                glTexCoordPointer(2, GL_FLOAT, 0, sprite_texcoords);
+                glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+                // TODO: See if I can somehow change the format of the color pointer, or maybe
+                // change the internal color representation on iOS.
+                glColorPointer(4, GL_UNSIGNED_BYTE, 0, sprite_colors);
+                glEnableClientState(GL_COLOR_ARRAY);
+                
+                is_setup = true;
+            }
+            
+            if (render_state.texture) {
+                sprite_texcoords[sprite_counter * 12 +  0] = left;
+                sprite_texcoords[sprite_counter * 12 +  1] = top;
+                sprite_texcoords[sprite_counter * 12 +  2] = right;
+                sprite_texcoords[sprite_counter * 12 +  3] = top;
+                sprite_texcoords[sprite_counter * 12 +  4] = left;
+                sprite_texcoords[sprite_counter * 12 +  5] = bottom;
+                
+                sprite_texcoords[sprite_counter * 12 +  6] = right;
+                sprite_texcoords[sprite_counter * 12 +  7] = top;
+                sprite_texcoords[sprite_counter * 12 +  8] = left;
+                sprite_texcoords[sprite_counter * 12 +  9] = bottom;
+                sprite_texcoords[sprite_counter * 12 + 10] = right;
+                sprite_texcoords[sprite_counter * 12 + 11] = bottom;
+            }
+
+            for (int i = 0; i < 3; ++i) {
+                sprite_vertices[sprite_counter * 12 + i * 2 + 0] = vertices[i].x;
+                sprite_vertices[sprite_counter * 12 + i * 2 + 1] = vertices[i].y;
+                sprite_colors[sprite_counter * 6 + i]            = vertices[i].c.abgr();
+            }
+            for (int i = 0; i < 3; ++i) {
+                sprite_vertices[sprite_counter * 12 + 6 + i * 2 + 0] = vertices[i + 1].x;
+                sprite_vertices[sprite_counter * 12 + 6 + i * 2 + 1] = vertices[i + 1].y;
+                sprite_colors[sprite_counter * 6 + 3 + i]            = vertices[i + 1].c.abgr();
+            }
+            
+            ++sprite_counter;
+            if (sprite_counter == MAX_AUTOGROUP || next == 0
+                || !(next->render_state == render_state)) {
+                glDrawArrays(GL_TRIANGLES, 0, 6 * sprite_counter);
+                sprite_counter = 0;
+            }
+            #else
+            if (vertices_or_block_index == 2) {
+                glBegin(GL_LINES);
+            }
+            else if (vertices_or_block_index == 3) {
+                glBegin(GL_TRIANGLES);
+            }
+            else { // vertices_or_block_index == 4
+                glBegin(GL_QUADS);
+            }
+            
+            for (unsigned i = 0; i < vertices_or_block_index; i++) {
+                glColor4ubv(reinterpret_cast<const GLubyte*>(&vertices[i].c));
+                if (render_state.texture) {
+                    switch (i) {
+                    case 0:
+                        glTexCoord2f(left, top);
+                        break;
+                    case 1:
+                        glTexCoord2f(right, top);
+                        break;
+                    case 2:
+                        glTexCoord2f(right, bottom);
+                        break;
+                    case 3:
+                        glTexCoord2f(left, bottom);
+                        break;
+                    }
+                }
+                glVertex2f(vertices[i].x, vertices[i].y);
+            }
+            
+            glEnd();
+            #endif
+        }
+        
+        void compile_to(VertexArrays& vas) const
+        {
+            // Copy vertex data and apply & forget about the transform.
+            // This is important because the pointed-to transform will be gone by the next
+            // frame anyway.
+            ArrayVertex result[4];
+            for (int i = 0; i < 4; ++i) {
+                result[i].vertices[0] = vertices[i].x;
+                result[i].vertices[1] = vertices[i].y;
+                result[i].vertices[2] = 0;
+                result[i].color       = vertices[i].c.abgr();
+                apply_transform(*render_state.transform,
+                                result[i].vertices[0], result[i].vertices[1]);
+            }
+            RenderState va_render_state = render_state;
+            va_render_state.transform   = 0;
+            
+            result[0].tex_coords[0] = left,  result[0].tex_coords[1] = top;
+            result[1].tex_coords[0] = right, result[1].tex_coords[1] = top;
+            result[2].tex_coords[0] = right, result[2].tex_coords[1] = bottom;
+            result[3].tex_coords[0] = left,  result[3].tex_coords[1] = bottom;
+            
+            if (vas.empty() || !(vas.back().render_state == va_render_state)) {
+                vas.push_back(VertexArray());
+                vas.back().render_state = va_render_state;
+            }
+            
+            vas.back().vertices.insert(vas.back().vertices.end(), result, result + 4);
+        }
+        
+        bool operator<(const DrawOp& other) const
+        {
+            return z < other.z;
+        }
+    };
+}

data/src/DrawOpQueue.hpp

@@ -0,0 +1,190 @@
+#pragma once
+
+#include "ClipRectStack.hpp"
+#include "DrawOp.hpp"
+#include "GraphicsImpl.hpp"
+#include "TransformStack.hpp"
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <functional>
+#include <map>
+#include <vector>
+
+class Gosu::DrawOpQueue
+{
+    TransformStack transform_stack;
+    ClipRectStack clip_rect_stack;
+    bool rec;
+
+    std::vector<DrawOp> ops;
+    std::vector<std::function<void ()>> gl_blocks;
+
+public:
+    DrawOpQueue()
+    : rec(false)
+    {
+    }
+    
+    bool recording() const
+    {
+        return rec;
+    }
+    
+    void set_recording()
+    {
+        rec = true;
+    }
+    
+    void schedule_draw_op(DrawOp op)
+    {
+        if (clip_rect_stack.clipped_world_away()) {
+            return;
+        }
+
+    #ifdef GOSU_IS_OPENGLES
+        // No triangles, no lines supported
+        assert (op.vertices_or_block_index == 4);
+    #endif
+
+        op.render_state.transform = &transform_stack.current();
+        if (const ClipRect* cr = clip_rect_stack.maybe_effective_rect()) {
+            op.render_state.clip_rect = *cr;
+        }
+        ops.push_back(op);
+    }
+
+    void gl(std::function<void ()> gl_block, ZPos z)
+    {
+        // TODO: Document this case: Clipped-away GL blocks are *not* being run.
+        if (clip_rect_stack.clipped_world_away()) {
+            return;
+        }
+
+        int complement_of_block_index = ~(int)gl_blocks.size();
+        gl_blocks.push_back(gl_block);
+
+        DrawOp op;
+        op.vertices_or_block_index = complement_of_block_index;
+        op.render_state.transform = &transform_stack.current();
+        if (const ClipRect* cr = clip_rect_stack.maybe_effective_rect()) {
+            op.render_state.clip_rect = *cr;
+        }
+        op.z = z;
+        ops.push_back(op);
+    }
+
+    void begin_clipping(double x, double y, double width, double height, double screen_height)
+    {
+        if (recording()) {
+            throw std::logic_error("Clipping is not allowed while creating a macro");
+        }
+        
+        // Apply current transformation.
+
+        double left = x, right = x + width;
+        double top = y, bottom = y + height;
+
+        apply_transform(transform_stack.current(), left, top);
+        apply_transform(transform_stack.current(), right, bottom);
+
+        double phys_x      = std::min(left, right);
+        double phys_y      = std::min(top, bottom);
+        double phys_width  = std::abs(left - right);
+        double phys_height = std::abs(top - bottom);
+
+        // Adjust for OpenGL having the wrong idea of where y=0 is.
+        phys_y = screen_height - phys_y - phys_height;
+
+        clip_rect_stack.begin_clipping(phys_x, phys_y, phys_width, phys_height);
+    }
+
+    void end_clipping()
+    {
+        clip_rect_stack.end_clipping();
+    }
+
+    void set_base_transform(const Transform& base_transform)
+    {
+        transform_stack.set_base_transform(base_transform);
+    }
+
+    void push_transform(const Transform& transform)
+    {
+        transform_stack.push(transform);
+    }
+
+    void pop_transform()
+    {
+        transform_stack.pop();
+    }
+
+    void perform_draw_ops_andCode()
+    {
+        if (recording()) {
+            throw std::logic_error("Flushing to the screen is not allowed while recording a macro");
+        }
+        
+        // Apply Z-Ordering.
+        std::stable_sort(ops.begin(), ops.end());
+
+        RenderStateManager manager;
+        
+    #ifdef GOSU_IS_OPENGLES
+        if (ops.empty()) {
+            return;
+        }
+
+        auto current = ops.begin(), last = ops.end() - 1;
+        for (; current != last; ++current) {
+            manager.set_render_state(current->render_state);
+            current->perform(&*(current + 1));
+        }
+        manager.set_render_state(last->render_state);
+        last->perform(0);
+    #else
+        for (const auto& op : ops) {
+            manager.set_render_state(op.render_state);
+            if (op.vertices_or_block_index >= 0) {
+                op.perform(0);
+            }
+            else {
+                // GL code
+                int block_index = ~op.vertices_or_block_index;
+                assert (block_index >= 0);
+                assert (block_index < gl_blocks.size());
+                gl_blocks[block_index]();
+                manager.enforce_after_untrusted_gL();
+            }
+        }
+    #endif
+    }
+
+    void compile_to(VertexArrays& vas)
+    {
+        if (!gl_blocks.empty()) {
+            throw std::logic_error("Custom OpenGL code cannot be recorded as a macro");
+        }
+
+        std::stable_sort(ops.begin(), ops.end());
+        for (const auto& op : ops) {
+            op.compile_to(vas);
+        }
+    }
+
+    // This retains the current stack of transforms and clippings.
+    void clear_queue()
+    {
+        gl_blocks.clear();
+        ops.clear();
+    }
+
+    // This clears the queue and starts with new stacks. This must not be called
+    // when end_clipping/pop_transform calls might still be pending.
+    void reset()
+    {
+        transform_stack.reset();
+        clip_rect_stack.clear();
+        clear_queue();
+    }
+};