gosu 0.10.9.pre1 → 0.11.0

data/src/Graphics/DrawOpQueue.hpp

@@ -1,188 +0,0 @@
-#ifndef GOSU_SRC_GRAPHICS_DRAWOPQUEUE_HPP
-#define GOSU_SRC_GRAPHICS_DRAWOPQUEUE_HPP
-
-#include <Gosu/TR1.hpp>
-#include "Common.hpp"
-#include "TransformStack.hpp"
-#include "ClipRectStack.hpp"
-#include "DrawOp.hpp"
-#include <cassert>
-#include <algorithm>
-#include <map>
-#include <vector>
-#include <cmath>
-
-class Gosu::DrawOpQueue
-{
-    TransformStack transformStack;
-    ClipRectStack clipRectStack;
-    bool rec;
-
-    typedef std::vector<DrawOp> DrawOps;
-    DrawOps ops;
-    typedef std::vector<std::tr1::function<void()> > GLBlocks;
-    GLBlocks glBlocks;
-
-public:
-    DrawOpQueue()
-    : rec(false)
-    {
-    }
-    
-    bool recording() const
-    {
-        return rec;
-    }
-    
-    void setRecording()
-    {
-        rec = true;
-    }
-    
-    void scheduleDrawOp(DrawOp op)
-    {
-        if (clipRectStack.clippedWorldAway())
-            return;
-
-        #ifdef GOSU_IS_OPENGLES
-        // No triangles, no lines supported
-        assert (op.verticesOrBlockIndex == 4);
-        #endif
-
-        op.renderState.transform = &transformStack.current();
-        if (const ClipRect* cr = clipRectStack.maybeEffectiveRect())
-            op.renderState.clipRect = *cr;
-        ops.push_back(op);
-    }
-
-    void scheduleGL(std::tr1::function<void()> glBlock, ZPos z)
-    {
-        // TODO: Document this case: Clipped-away GL blocks are *not* being run.
-        if (clipRectStack.clippedWorldAway())
-            return;
-
-        int complementOfBlockIndex = ~(int)glBlocks.size();
-        glBlocks.push_back(glBlock);
-
-        DrawOp op;
-        op.verticesOrBlockIndex = complementOfBlockIndex;
-        op.renderState.transform = &transformStack.current();
-        if (const ClipRect* cr = clipRectStack.maybeEffectiveRect())
-            op.renderState.clipRect = *cr;
-        op.z = z;
-        ops.push_back(op);
-    }
-
-    void beginClipping(double x, double y, double width, double height, double screenHeight)
-    {
-        if (recording())
-            throw std::logic_error("Clipping is not allowed while creating a macro yet");
-        
-        // Apply current transformation.
-
-        double left = x, right = x + width;
-        double top = y, bottom = y + height;
-
-        applyTransform(transformStack.current(), left, top);
-        applyTransform(transformStack.current(), right, bottom);
-
-        double physX = std::min(left, right);
-        double physY = std::min(top, bottom);
-        double physWidth = std::abs(left - right);
-        double physHeight = std::abs(top - bottom);
-
-        // Adjust for OpenGL having the wrong idea of where y=0 is.
-        physY = screenHeight - physY - physHeight;
-
-        clipRectStack.beginClipping(physX, physY, physWidth, physHeight);
-    }
-
-    void endClipping()
-    {
-        clipRectStack.endClipping();
-    }
-
-    void setBaseTransform(const Transform& baseTransform)
-    {
-        transformStack.setBaseTransform(baseTransform);
-    }
-
-    void pushTransform(const Transform& transform)
-    {
-        transformStack.push(transform);
-    }
-
-    void popTransform()
-    {
-        transformStack.pop();
-    }
-
-    void performDrawOpsAndCode()
-    {
-        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;
-
-        DrawOps::const_iterator current = ops.begin(), last = ops.end() - 1;
-        for (; current != last; ++current)
-        {
-            manager.setRenderState(current->renderState);
-            current->perform(&*(current + 1));
-        }
-        manager.setRenderState(last->renderState);
-        last->perform(0);
-        #else
-        for (DrawOps::const_iterator current = ops.begin(), last = ops.end();
-            current != last; ++current)
-        {
-            manager.setRenderState(current->renderState);
-            if (current->verticesOrBlockIndex >= 0)
-                current->perform(0);
-            else
-            {
-                // GL code
-                int blockIndex = ~current->verticesOrBlockIndex;
-                assert (blockIndex >= 0);
-                assert (blockIndex < glBlocks.size());
-                glBlocks[blockIndex]();
-                manager.enforceAfterUntrustedGL();
-            }
-        }
-        #endif
-    }
-
-    void compileTo(VertexArrays& vas)
-    {
-        if (!glBlocks.empty())
-            throw std::logic_error("Custom OpenGL code cannot be recorded as a macro");
-
-        std::stable_sort(ops.begin(), ops.end());
-        for (DrawOps::const_iterator op = ops.begin(), end = ops.end(); op != end; ++op)
-            op->compileTo(vas);
-    }
-
-    // This retains the current stack of transforms and clippings.
-    void clearQueue()
-    {
-        glBlocks.clear();
-        ops.clear();
-    }
-
-    // This clears the queue and starts with new stacks. This must not be called
-    // when endClipping/popTransform calls might still be pending.
-    void reset()
-    {
-        transformStack.reset();
-        clipRectStack.clear();
-        clearQueue();
-    }
-};
-
-#endif

data/src/Graphics/Graphics.cpp

@@ -1,478 +0,0 @@
-#include <Gosu/Graphics.hpp>
-#include "Common.hpp"
-#include "DrawOp.hpp"
-#include "DrawOpQueue.hpp"
-#include "Texture.hpp"
-#include "TexChunk.hpp"
-#include "LargeImageData.hpp"
-#include "Macro.hpp"
-#include <Gosu/Bitmap.hpp>
-#include <Gosu/Image.hpp>
-#include <Gosu/Platform.hpp>
-#include <cmath>
-#include <algorithm>
-#include <limits>
-
-namespace Gosu
-{
-    namespace
-    {
-        Graphics* currentGraphicsPointer = 0;
-        
-        Graphics& currentGraphics()
-        {
-            if (currentGraphicsPointer == 0)
-                throw std::logic_error("Gosu::Graphics can only be drawn to while rendering");
-            
-            return *currentGraphicsPointer;
-        }
-        
-        typedef std::vector<std::tr1::shared_ptr<Texture> > Textures;
-        Textures textures;
-        
-        DrawOpQueueStack queues;
-        
-        DrawOpQueue& currentQueue()
-        {
-            if (queues.empty())
-                throw std::logic_error("There is no rendering queue for this operation");
-            return queues.back();
-        }
-    }
-}
-
-struct Gosu::Graphics::Impl
-{
-    unsigned virtWidth, virtHeight;
-    unsigned physWidth, physHeight;
-    double blackWidth, blackHeight;
-    bool fullscreen;
-    Transform baseTransform;
-    
-    DrawOpQueueStack warmedUpQueues;
-
-    void updateBaseTransform()
-    {
-        double scaleX = 1.0 * physWidth / virtWidth;
-        double scaleY = 1.0 * physHeight / virtHeight;
-        double scaleFactor = std::min(scaleX, scaleY);
-
-        Transform scaleTransform = scale(scaleFactor);
-        Transform translateTransform = translate(blackWidth, blackHeight);
-        baseTransform = concat(translateTransform, scaleTransform);
-    }
-};
-
-Gosu::Graphics::Graphics(unsigned physWidth, unsigned physHeight, bool fullscreen)
-: pimpl(new Impl)
-{
-    pimpl->virtWidth  = physWidth;
-    pimpl->virtHeight = physHeight;
-    pimpl->fullscreen = fullscreen;
-    pimpl->blackWidth = 0;
-    pimpl->blackHeight = 0;
-
-    // TODO: Should be merged into RenderState and removed from Graphics.
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
-    glEnable(GL_BLEND);
-
-    setPhysicalResolution(physWidth, physHeight);
-}
-
-Gosu::Graphics::~Graphics()
-{
-    if (currentGraphicsPointer == this)
-        currentGraphicsPointer = 0;
-}
-
-unsigned Gosu::Graphics::width() const
-{
-    return pimpl->virtWidth;
-}
-
-unsigned Gosu::Graphics::height() const
-{
-    return pimpl->virtHeight;
-}
-
-bool Gosu::Graphics::fullscreen() const
-{
-    return pimpl->fullscreen;
-}
-
-void Gosu::Graphics::setResolution(unsigned virtualWidth, unsigned virtualHeight,
-    double horizontalBlackBarWidth, double verticalBlackBarHeight)
-{
-    if (virtualWidth == 0 || virtualHeight == 0)
-        throw std::invalid_argument("Invalid virtual resolution.");
-    
-    pimpl->virtWidth = virtualWidth;
-    pimpl->virtHeight = virtualHeight;
-    pimpl->blackWidth = horizontalBlackBarWidth;
-    pimpl->blackHeight = verticalBlackBarHeight;
-
-    pimpl->updateBaseTransform();
-}
-
-bool Gosu::Graphics::begin(Gosu::Color clearWithColor)
-{
-    if (currentGraphicsPointer != 0)
-        throw std::logic_error("Cannot nest calls to Gosu::Graphics::begin()");
-    
-    // Cancel all recording or whatever that might still be in progress...
-    queues.clear();
-    
-    if (pimpl->warmedUpQueues.size() == 1)
-    {
-        // If we already have a "warmed up" queue, use that instead.
-        // -> All internals std::vectors will already have a lot of capacity.
-        // This helps reduce allocations during normal operation.
-        queues.clear();
-        queues.swap(pimpl->warmedUpQueues);
-    }
-    else
-    {
-        // Create default draw-op queue.
-        queues.resize(1);
-    }
-    
-    queues.back().setBaseTransform(pimpl->baseTransform);
-    
-    glClearColor(clearWithColor.red() / 255.f, clearWithColor.green() / 255.f,
-        clearWithColor.blue() / 255.f, clearWithColor.alpha() / 255.f);
-    glClear(GL_COLOR_BUFFER_BIT);
-    
-    currentGraphicsPointer = this;
-    
-    return true;
-}
-
-void Gosu::Graphics::end()
-{
-    // If recording is in process, cancel it.
-    while (currentQueue().recording()) {
-        queues.pop_back();
-    }
-    
-    flush();
-    
-    if (pimpl->blackHeight || pimpl->blackWidth) {
-        if (pimpl->blackHeight) {
-            drawQuad(0, -pimpl->blackHeight, Color::BLACK,
-                     width(), -pimpl->blackHeight, Color::BLACK,
-                     0, 0, Color::BLACK,
-                     width(), 0, Color::BLACK, 0);
-            drawQuad(0, height(), Color::BLACK,
-                     width(), height(), Color::BLACK,
-                     0, height() + pimpl->blackHeight, Color::BLACK,
-                     width(), height() + pimpl->blackHeight, Color::BLACK, 0);
-        }
-        else if (pimpl->blackWidth) {
-            drawQuad(-pimpl->blackWidth, 0, Color::BLACK,
-                     0, 0, Color::BLACK,
-                     -pimpl->blackWidth, height(), Color::BLACK,
-                     0, height(), Color::BLACK, 0);
-            drawQuad(width(), 0, Color::BLACK,
-                     width() + pimpl->blackWidth, 0, Color::BLACK,
-                     width(), height(), Color::BLACK,
-                     width() + pimpl->blackWidth, height(), Color::BLACK, 0);
-        }
-        flush();
-    }
-    
-    glFlush();
-    
-    currentGraphicsPointer = 0;
-    
-    // Clear leftover transforms, clip rects etc.
-    if (queues.size() == 1)
-    {
-        queues.swap(pimpl->warmedUpQueues);
-        pimpl->warmedUpQueues.back().reset();
-    }
-    else
-    {
-        queues.clear();
-    }
-}
-
-void Gosu::Graphics::flush()
-{
-    currentQueue().performDrawOpsAndCode();
-    currentQueue().clearQueue();
-}
-
-void Gosu::Graphics::beginGL()
-{
-    if (currentQueue().recording())
-        throw std::logic_error("Custom OpenGL is not allowed while creating a macro");
-    
-#ifdef GOSU_IS_OPENGLES
-    throw std::logic_error("Custom OpenGL ES is not supported yet");
-#else
-    flush();
-    glPushAttrib(GL_ALL_ATTRIB_BITS);
-    glDisable(GL_BLEND);
-    while (glGetError() != GL_NO_ERROR);
-#endif
-}
-
-void Gosu::Graphics::endGL()
-{
-#ifdef GOSU_IS_OPENGLES
-    throw std::logic_error("Custom OpenGL ES is not supported yet");
-#else
-    Graphics& cg = currentGraphics();
-    
-    glPopAttrib();
-
-    // Restore matrices.
-    // TODO: Should be merged into RenderState and removed from Graphics.
-
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-    glViewport(0, 0, cg.pimpl->physWidth, cg.pimpl->physHeight);
-    glOrtho(0, cg.pimpl->physWidth, cg.pimpl->physHeight, 0, -1, 1);
-
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
-    glEnable(GL_BLEND);
-#endif
-}
-
-#ifdef GOSU_IS_OPENGLES
-void Gosu::Graphics::scheduleGL(const std::tr1::function<void()>& functor, Gosu::ZPos z)
-{
-    throw std::logic_error("Custom OpenGL ES is not supported yet");
-}
-#else
-namespace Gosu
-{
-    struct RunGLFunctor
-    {
-        Graphics& graphics;
-        std::tr1::function<void()> functor;
-        
-        RunGLFunctor(Graphics& graphics, const std::tr1::function<void()>& functor)
-        : graphics(graphics), functor(functor)
-        {
-        }
-        
-        void operator()() const
-        {
-            // Inlined beginGL() to avoid flushing.
-            glPushAttrib(GL_ALL_ATTRIB_BITS);
-            glDisable(GL_BLEND);
-            while (glGetError() != GL_NO_ERROR);
-            
-            functor();
-            
-            graphics.endGL();
-        }
-    };
-}
-
-void Gosu::Graphics::scheduleGL(const std::tr1::function<void()>& functor, Gosu::ZPos z)
-{
-    currentQueue().scheduleGL(RunGLFunctor(currentGraphics(), functor), z);
-}
-#endif
-
-void Gosu::Graphics::beginClipping(double x, double y, double width, double height)
-{
-    double screenHeight = currentGraphics().pimpl->physHeight;
-    currentQueue().beginClipping(x, y, width, height, screenHeight);
-}
-
-void Gosu::Graphics::endClipping()
-{
-    currentQueue().endClipping();
-}
-
-void Gosu::Graphics::beginRecording()
-{
-    queues.resize(queues.size() + 1);
-    currentQueue().setRecording();
-}
-
-GOSU_UNIQUE_PTR<Gosu::ImageData> Gosu::Graphics::endRecording(int width, int height)
-{
-    if (! currentQueue().recording())
-        throw std::logic_error("No macro recording in progress that can be captured");
-    
-    GOSU_UNIQUE_PTR<ImageData> result(new Macro(currentQueue(), width, height));
-    queues.pop_back();
-    return result;
-}
-
-void Gosu::Graphics::pushTransform(const Gosu::Transform& transform)
-{
-    currentQueue().pushTransform(transform);
-}
-
-void Gosu::Graphics::popTransform()
-{
-    currentQueue().popTransform();
-}
-
-void Gosu::Graphics::drawLine(double x1, double y1, Color c1,
-    double x2, double y2, Color c2, ZPos z, AlphaMode mode)
-{
-    DrawOp op;
-    op.renderState.mode = mode;
-    op.verticesOrBlockIndex = 2;
-    op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
-    op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
-    op.z = z;
-    
-    currentQueue().scheduleDrawOp(op);
-}
-
-void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
-    double x2, double y2, Color c2, double x3, double y3, Color c3,
-    ZPos z, AlphaMode mode)
-{
-    DrawOp op;
-    op.renderState.mode = mode;
-    op.verticesOrBlockIndex = 3;
-    op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
-    op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
-    op.vertices[2] = DrawOp::Vertex(x3, y3, c3);
-#ifdef GOSU_IS_OPENGLES
-    op.verticesOrBlockIndex = 4;
-    op.vertices[3] = op.vertices[2];
-#endif
-    op.z = z;
-    
-    currentQueue().scheduleDrawOp(op);
-}
-
-void Gosu::Graphics::drawQuad(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)
-{
-    reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
-
-    DrawOp op;
-    op.renderState.mode = mode;
-    op.verticesOrBlockIndex = 4;
-    op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
-    op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
-// TODO: Should be harmonized
-#ifdef GOSU_IS_OPENGLES
-    op.vertices[2] = DrawOp::Vertex(x3, y3, c3);
-    op.vertices[3] = DrawOp::Vertex(x4, y4, c4);
-#else
-    op.vertices[3] = DrawOp::Vertex(x3, y3, c3);
-    op.vertices[2] = DrawOp::Vertex(x4, y4, c4);
-#endif
-    op.z = z;
-    
-    currentQueue().scheduleDrawOp(op);
-}
-
-void Gosu::Graphics::scheduleDrawOp(const Gosu::DrawOp &op)
-{
-    currentQueue().scheduleDrawOp(op);
-}
-
-void Gosu::Graphics::setPhysicalResolution(unsigned physWidth, unsigned physHeight)
-{
-    pimpl->physWidth = physWidth;
-    pimpl->physHeight = physHeight;
-    // TODO: Should be merged into RenderState and removed from Graphics.
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-    glViewport(0, 0, physWidth, physHeight);
-#ifdef GOSU_IS_OPENGLES
-    glOrthof(0, physWidth, physHeight, 0, -1, 1);
-#else
-    glOrtho(0, physWidth, physHeight, 0, -1, 1);
-#endif
-
-    pimpl->updateBaseTransform();
-}
-
-GOSU_UNIQUE_PTR<Gosu::ImageData> Gosu::Graphics::createImage(
-    const Bitmap& src, unsigned srcX, unsigned srcY,
-    unsigned srcWidth, unsigned srcHeight, unsigned flags)
-{
-    static const unsigned maxSize = MAX_TEXTURE_SIZE;
-    
-    // Backwards compatibility: This used to be 'bool tileable'.
-    if (flags == 1)
-        flags = ifTileable;
-
-    bool wantsRetro = (flags & ifRetro);
-    
-    // Special case: If the texture is supposed to have hard borders, is
-    // quadratic, has a size that is at least 64 pixels but no more than maxSize
-    // pixels and a power of two, create a single texture just for this image.
-    if ((flags & ifTileable) == ifTileable &&
-        srcWidth == srcHeight &&
-        (srcWidth & (srcWidth - 1)) == 0 &&
-        srcWidth >= 64 && srcWidth <= maxSize)
-    {
-        std::tr1::shared_ptr<Texture> texture(new Texture(srcWidth, wantsRetro));
-        GOSU_UNIQUE_PTR<ImageData> data;
-        
-        // Use the source bitmap directly if the source area completely covers
-        // it.
-        if (srcX == 0 && srcWidth == src.width() &&
-            srcY == 0 && srcHeight == src.height())
-        {
-            data = texture->tryAlloc(texture, src, 0);
-        }
-        else
-        {
-            Bitmap bmp(srcWidth, srcHeight);
-            bmp.insert(src, 0, 0, srcX, srcY, srcWidth, srcHeight);
-            data = texture->tryAlloc(texture, bmp, 0);
-        }
-        
-        if (!data.get())
-            throw std::logic_error("Internal texture block allocation error");
-        return GOSU_MOVE_UNIQUE_PTR(data);
-    }
-    
-    // Too large to fit on a single texture. 
-    if (srcWidth > maxSize - 2 || srcHeight > maxSize - 2)
-    {
-        Bitmap bmp(srcWidth, srcHeight);
-        bmp.insert(src, 0, 0, srcX, srcY, srcWidth, srcHeight);
-        GOSU_UNIQUE_PTR<ImageData> lidi;
-        lidi.reset(new LargeImageData(bmp, maxSize - 2, maxSize - 2, flags));
-        return GOSU_MOVE_UNIQUE_PTR(lidi);
-    }
-    
-    Bitmap bmp;
-    applyBorderFlags(bmp, src, srcX, srcY, srcWidth, srcHeight, flags);
-
-    // Try to put the bitmap into one of the already allocated textures.
-    for (Textures::iterator i = textures.begin(); i != textures.end(); ++i)
-    {
-        std::tr1::shared_ptr<Texture> texture(*i);
-        
-        if (texture->retro() != wantsRetro)
-            continue;
-        
-        GOSU_UNIQUE_PTR<ImageData> data;
-        data = texture->tryAlloc(texture, bmp, 1);
-        if (data.get())
-            return GOSU_MOVE_UNIQUE_PTR(data);
-    }
-    
-    // All textures are full: Create a new one.
-    
-    std::tr1::shared_ptr<Texture> texture;
-    texture.reset(new Texture(maxSize, wantsRetro));
-    textures.push_back(texture);
-    
-    GOSU_UNIQUE_PTR<ImageData> data;
-    data = texture->tryAlloc(texture, bmp, 1);
-    if (!data.get())
-        throw std::logic_error("Internal texture block allocation error");
-
-    return GOSU_MOVE_UNIQUE_PTR(data);
-}