/*
  ==============================================================================

   This file is part of the JUCE framework.
   Copyright (c) Raw Material Software Limited

   JUCE is an open source framework subject to commercial or open source
   licensing.

   By downloading, installing, or using the JUCE framework, or combining the
   JUCE framework with any other source code, object code, content or any other
   copyrightable work, you agree to the terms of the JUCE End User Licence
   Agreement, and all incorporated terms including the JUCE Privacy Policy and
   the JUCE Website Terms of Service, as applicable, which will bind you. If you
   do not agree to the terms of these agreements, we will not license the JUCE
   framework to you, and you must discontinue the installation or download
   process and cease use of the JUCE framework.

   JUCE End User Licence Agreement: https://juce.com/legal/juce-9-licence/
   JUCE Privacy Policy: https://juce.com/juce-privacy-policy
   JUCE Website Terms of Service: https://juce.com/juce-website-terms-of-service/

   Or:

   You may also use this code under the terms of the AGPLv3:
   https://www.gnu.org/licenses/agpl-3.0.en.html

   THE JUCE FRAMEWORK IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL
   WARRANTIES, WHETHER EXPRESSED OR IMPLIED, INCLUDING WARRANTY OF
   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED.

  ==============================================================================
*/

namespace juce
{

extern void (*clearOpenGLGlyphCache)(); // declared in juce_graphics

namespace OpenGLRendering
{

struct TextureInfo
{
    GLuint textureID;
    int imageWidth, imageHeight;
    float fullWidthProportion, fullHeightProportion;
};

//==============================================================================
// This list persists in the OpenGLContext, and will re-use cached textures which
// are created from Images.
struct CachedImageList final : public ReferenceCountedObject,
                               private ImagePixelData::Listener
{
    explicit CachedImageList (OpenGLContext& c) noexcept
        : context (c), maxCacheSize (c.getImageCacheSize()) {}

    static CachedImageList* get (OpenGLContext& c)
    {
        const char cacheValueID[] = "CachedImages";
        auto list = static_cast<CachedImageList*> (c.getAssociatedObject (cacheValueID));

        if (list == nullptr)
        {
            list = new CachedImageList (c);
            c.setAssociatedObject (cacheValueID, list);
        }

        return list;
    }

    TextureInfo getTextureFor (const Image& image)
    {
        auto pixelData = image.getPixelData();
        auto* c = findCachedImage (pixelData.get());

        if (c == nullptr)
        {
            if (auto fb = OpenGLImageType::getFrameBufferFrom (image))
            {
                TextureInfo t;
                t.textureID = fb->getTextureID();
                t.imageWidth = image.getWidth();
                t.imageHeight = image.getHeight();
                t.fullWidthProportion  = 1.0f;
                t.fullHeightProportion = 1.0f;

                return t;
            }

            c = images.add (new CachedImage (*this, pixelData.get()));
            totalSize += c->imageSize;

            while (totalSize > maxCacheSize && images.size() > 1 && totalSize > 0)
                removeOldestItem();
        }

        return c->getTextureInfo();
    }

    struct CachedImage
    {
        CachedImage (CachedImageList& list, ImagePixelData* im)
            : owner (list), pixelData (im),
              lastUsed (Time::getCurrentTime()),
              imageSize ((size_t) (im->width * im->height))
        {
            pixelData->listeners.add (&owner);
        }

        ~CachedImage()
        {
            if (pixelData != nullptr)
                pixelData->listeners.remove (&owner);
        }

        TextureInfo getTextureInfo()
        {
            if (pixelData == nullptr)
                return {};

            TextureInfo t;

            if (textureNeedsReloading)
            {
                textureNeedsReloading = false;
                texture.loadImage (Image (*pixelData));
            }

            t.textureID = texture.getTextureID();
            t.imageWidth = pixelData->width;
            t.imageHeight = pixelData->height;
            t.fullWidthProportion  = (float) t.imageWidth  / (float) texture.getWidth();
            t.fullHeightProportion = (float) t.imageHeight / (float) texture.getHeight();

            lastUsed = Time::getCurrentTime();
            return t;
        }

        CachedImageList& owner;
        ImagePixelData* pixelData;
        OpenGLTexture texture;
        Time lastUsed;
        const size_t imageSize;
        bool textureNeedsReloading = true;

        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (CachedImage)
    };

    using Ptr = ReferenceCountedObjectPtr<CachedImageList>;

private:
    OpenGLContext& context;
    OwnedArray<CachedImage> images;
    size_t totalSize = 0;
    const size_t maxCacheSize;

    bool canUseContext() const noexcept
    {
        return OpenGLContext::getCurrentContext() == &context;
    }

    void imageDataChanged (ImagePixelData* im) override
    {
        if (auto* c = findCachedImage (im))
            c->textureNeedsReloading = true;
    }

    void imageDataBeingDeleted (ImagePixelData* im) override
    {
        const auto iter = std::find_if (images.begin(), images.end(), [&] (auto image)
        {
            return image->pixelData == im;
        });

        if (iter == images.end())
            return;

        if (canUseContext())
        {
            totalSize -= (*iter)->imageSize;
            images.remove ((int) std::distance (images.begin(), iter));
        }
        else
        {
            (*iter)->pixelData = nullptr;
        }
    }

    CachedImage* findCachedImage (ImagePixelData* pixelData) const
    {
        for (auto& i : images)
            if (i->pixelData == pixelData)
                return i;

        return {};
    }

    void removeOldestItem()
    {
        const auto iter = std::min_element (images.begin(), images.end(), [&] (auto a, auto b)
        {
            return a->lastUsed < b->lastUsed;
        });

        if (iter == images.end())
            return;

        totalSize -= (*iter)->imageSize;
        images.remove ((int) std::distance (images.begin(), iter));
    }

    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (CachedImageList)
};

//==============================================================================
struct Target
{
    Target (OpenGLContext& c, GLuint fbID, int width, int height) noexcept
        : context (c), frameBufferID (fbID), bounds (width, height)
    {}

    Target (OpenGLContext& c, OpenGLFrameBuffer& fb, Point<int> origin) noexcept
        : context (c), frameBufferID (fb.getFrameBufferID()),
          bounds (origin.x, origin.y, fb.getWidth(), fb.getHeight())
    {
        jassert (frameBufferID != 0); // trying to render into an uninitialised framebuffer object
    }

    Target (const Target& other) noexcept
        : context (other.context), frameBufferID (other.frameBufferID), bounds (other.bounds)
    {}

    Target& operator= (const Target& other) noexcept
    {
        frameBufferID = other.frameBufferID;
        bounds = other.bounds;
        return *this;
    }

    void makeActive() const noexcept
    {
       #if JUCE_WINDOWS
        if (context.extensions.glBindFramebuffer != nullptr)
       #endif
            context.extensions.glBindFramebuffer (GL_FRAMEBUFFER, frameBufferID);

        glViewport (0, 0, bounds.getWidth(), bounds.getHeight());
        glDisable (GL_DEPTH_TEST);
    }

    OpenGLContext& context;
    GLuint frameBufferID;
    Rectangle<int> bounds;
};

//==============================================================================
struct PositionedTexture
{
    PositionedTexture (OpenGLTexture& texture, const EdgeTable& et, Rectangle<int> clipRegion)
        : clip (clipRegion.getIntersection (et.getMaximumBounds()))
    {
        if (clip.contains (et.getMaximumBounds()))
        {
            createMap (texture, et);
        }
        else
        {
            EdgeTable et2 (clip);
            et2.clipToEdgeTable (et);
            createMap (texture, et2);
        }
    }

    PositionedTexture (GLuint texture, Rectangle<int> r, Rectangle<int> clipRegion) noexcept
        : textureID (texture), area (r), clip (clipRegion)
    {}

    GLuint textureID;
    Rectangle<int> area, clip;

private:
    void createMap (OpenGLTexture& texture, const EdgeTable& et)
    {
        EdgeTableAlphaMap alphaMap (et);
        texture.loadAlpha (alphaMap.data, alphaMap.area.getWidth(), alphaMap.area.getHeight());
        textureID = texture.getTextureID();
        area = alphaMap.area;
    }

    struct EdgeTableAlphaMap
    {
        EdgeTableAlphaMap (const EdgeTable& et)
            : area (et.getMaximumBounds().withSize (nextPowerOfTwo (et.getMaximumBounds().getWidth()),
                                                    nextPowerOfTwo (et.getMaximumBounds().getHeight())))
        {
            data.calloc (area.getWidth() * area.getHeight());
            et.iterate (*this);
        }

        inline void setEdgeTableYPos (const int y) noexcept
        {
            currentLine = data + (area.getBottom() - 1 - y) * area.getWidth() - area.getX();
        }

        inline void handleEdgeTablePixel (const int x, const int alphaLevel) const noexcept
        {
            currentLine[x] = (uint8) alphaLevel;
        }

        inline void handleEdgeTablePixelFull (const int x) const noexcept
        {
            currentLine[x] = 255;
        }

        inline void handleEdgeTableLine (int x, int width, const int alphaLevel) const noexcept
        {
            memset (currentLine + x, (uint8) alphaLevel, (size_t) width);
        }

        inline void handleEdgeTableLineFull (int x, int width) const noexcept
        {
            memset (currentLine + x, 255, (size_t) width);
        }

        void handleEdgeTableRectangle (int x, int y, int width, int height, int alphaLevel) noexcept
        {
            while (--height >= 0)
            {
                setEdgeTableYPos (y++);
                handleEdgeTableLine (x, width, alphaLevel);
            }
        }

        void handleEdgeTableRectangleFull (int x, int y, int width, int height) noexcept
        {
            while (--height >= 0)
            {
                setEdgeTableYPos (y++);
                handleEdgeTableLineFull (x, width);
            }
        }

        HeapBlock<uint8> data;
        const Rectangle<int> area;

    private:
        uint8* currentLine;

        JUCE_DECLARE_NON_COPYABLE (EdgeTableAlphaMap)
    };
};

//==============================================================================
struct ShaderPrograms final : public ReferenceCountedObject
{
    explicit ShaderPrograms (OpenGLContext& context)
        : solidColourProgram (context),
          solidColourMasked (context),
          radialGradient (context),
          radialGradientMasked (context),
          linearGradient1 (context),
          linearGradient1Masked (context),
          linearGradient2 (context),
          linearGradient2Masked (context),
          image (context),
          imageMasked (context),
          tiledImage (context),
          tiledImageMasked (context),
          copyTexture (context),
          maskTexture (context)
    {}

    using Ptr = ReferenceCountedObjectPtr<ShaderPrograms>;

    //==============================================================================
    struct ShaderProgramHolder
    {
        ShaderProgramHolder (OpenGLContext& context, const char* fragmentShader, const char* vertexShader)
            : program (context)
        {
            JUCE_CHECK_OPENGL_ERROR

            if (vertexShader == nullptr)
                vertexShader = "attribute vec2 position;"
                               "attribute vec4 colour;"
                               "uniform vec4 screenBounds;"
                               "varying #mediump# vec4 frontColour;"
                               "varying #highp# vec2 pixelPos;"
                               "void main()"
                               "{"
                                 "frontColour = colour;"
                                 "vec2 adjustedPos = position - screenBounds.xy;"
                                 "pixelPos = adjustedPos;"
                                 "vec2 scaledPos = adjustedPos / screenBounds.zw;"
                                 "gl_Position = vec4 (scaledPos.x - 1.0, 1.0 - scaledPos.y, 0, 1.0);"
                               "}";

            if (program.addVertexShader (OpenGLHelpers::translateVertexShaderToV3 (preprocessShaderPrecisionStatements (vertexShader)))
                 && program.addFragmentShader (OpenGLHelpers::translateFragmentShaderToV3 (preprocessShaderPrecisionStatements (fragmentShader)))
                 && program.link())
            {
                JUCE_CHECK_OPENGL_ERROR
            }
            else
            {
                lastError = program.getLastError();
            }
        }

        virtual ~ShaderProgramHolder() = default;

        OpenGLShaderProgram program;
        String lastError;
    };

    struct ShaderBase : public ShaderProgramHolder
    {
        ShaderBase (OpenGLContext& context, const char* fragmentShader, const char* vertexShader = nullptr)
            : ShaderProgramHolder (context, fragmentShader, vertexShader),
              positionAttribute (program, "position"),
              colourAttribute (program, "colour"),
              screenBounds (program, "screenBounds")
        {}

        Rectangle<float> get2DBounds() const
        {
            GLfloat params[4]{};
            glGetUniformfv (program.getProgramID(), screenBounds.uniformID, params);
            return { params[0], params[1], 2 * params[2], 2 * params[3] };
        }

        void set2DBounds (Rectangle<float> bounds)
        {
            screenBounds.set (bounds.getX(), bounds.getY(), 0.5f * bounds.getWidth(), 0.5f * bounds.getHeight());
        }

        void bindAttributes()
        {
            gl::glVertexAttribPointer ((GLuint) positionAttribute.attributeID, 2, GL_SHORT, GL_FALSE, 8, nullptr);
            gl::glVertexAttribPointer ((GLuint) colourAttribute.attributeID, 4, GL_UNSIGNED_BYTE, GL_TRUE, 8, (void*) 4);
            gl::glEnableVertexAttribArray ((GLuint) positionAttribute.attributeID);
            gl::glEnableVertexAttribArray ((GLuint) colourAttribute.attributeID);
        }

        void unbindAttributes()
        {
            gl::glDisableVertexAttribArray ((GLuint) positionAttribute.attributeID);
            gl::glDisableVertexAttribArray ((GLuint) colourAttribute.attributeID);
        }

        OpenGLShaderProgram::Attribute positionAttribute, colourAttribute;
        OpenGLShaderProgram::Uniform screenBounds;
        std::function<void (OpenGLShaderProgram&)> onShaderActivated;
    };

    /*  If the shader currently bound to the active context is owned by ShaderPrograms, this returns
        the specific shader that is currently bound, or nullptr if none of the shaders match.
    */
    ShaderBase* findActiveShader()
    {
        GLint program{};
        glGetIntegerv (GL_CURRENT_PROGRAM, &program);

        ShaderBase* ptrs[] { &solidColourProgram,
                             &solidColourMasked,
                             &radialGradient,
                             &radialGradientMasked,
                             &linearGradient1,
                             &linearGradient1Masked,
                             &linearGradient2,
                             &linearGradient2Masked,
                             &image,
                             &imageMasked,
                             &tiledImage,
                             &tiledImageMasked,
                             &copyTexture,
                             &maskTexture };

        const auto iter = std::find_if (std::begin (ptrs),
                                        std::end (ptrs),
                                        [&] (auto* x) { return (GLint) x->program.getProgramID() == program; });
        return iter != std::end (ptrs) ? *iter : nullptr;
    }

    struct MaskedShaderParams
    {
        MaskedShaderParams (OpenGLShaderProgram& program)
            : maskTexture (program, "maskTexture"),
              maskBounds  (program, "maskBounds")
        {}

        void setBounds (Rectangle<int> area, const Target& target, GLint textureIndex) const
        {
            maskTexture.set (textureIndex);
            maskBounds.set (area.getX() - target.bounds.getX(),
                            area.getY() - target.bounds.getY(),
                            area.getWidth(), area.getHeight());
        }

        OpenGLShaderProgram::Uniform maskTexture, maskBounds;
    };

    //==============================================================================
    #define JUCE_DECLARE_VARYING_COLOUR   "varying #mediump# vec4 frontColour;"
    #define JUCE_DECLARE_VARYING_PIXELPOS "varying #highp# vec2 pixelPos;"

    struct SolidColourProgram final : public ShaderBase
    {
        SolidColourProgram (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_VARYING_COLOUR
                          "void main() { gl_FragColor = frontColour; }")
        {}
    };

    #define JUCE_DECLARE_MASK_UNIFORMS  "uniform sampler2D maskTexture;" \
                                        "uniform ivec4 maskBounds;"
    #define JUCE_FRAGCOORD_TO_MASK_POS  "vec2 ((pixelPos.x - float (maskBounds.x)) / float (maskBounds.z)," \
                                              "1.0 - (pixelPos.y - float (maskBounds.y)) / float (maskBounds.w))"
    #define JUCE_GET_MASK_ALPHA         "texture2D (maskTexture, " JUCE_FRAGCOORD_TO_MASK_POS ").a"

    struct SolidColourMaskedProgram final : public ShaderBase
    {
        SolidColourMaskedProgram (OpenGLContext& context)
            : ShaderBase (context,
                          JUCE_DECLARE_MASK_UNIFORMS JUCE_DECLARE_VARYING_COLOUR JUCE_DECLARE_VARYING_PIXELPOS
                          "void main() {"
                            "gl_FragColor = frontColour * " JUCE_GET_MASK_ALPHA ";"
                          "}"),
              maskParams (program)
        {}

        MaskedShaderParams maskParams;
    };

    //==============================================================================
    struct RadialGradientParams
    {
        RadialGradientParams (OpenGLShaderProgram& program)
            : gradientTexture (program, "gradientTexture"),
              matrix (program, "matrix")
        {}

        void setMatrix (Point<float> p1, Point<float> p2, Point<float> p3)
        {
            auto t = AffineTransform::fromTargetPoints (p1, Point<float>(),
                                                        p2, Point<float> (1.0f, 0.0f),
                                                        p3, Point<float> (0.0f, 1.0f));
            const GLfloat m[] = { t.mat00, t.mat01, t.mat02, t.mat10, t.mat11, t.mat12 };
            matrix.set (m, 6);
        }

        OpenGLShaderProgram::Uniform gradientTexture, matrix;
    };

    #define JUCE_DECLARE_MATRIX_UNIFORM   "uniform #highp# float matrix[6];"
    #define JUCE_DECLARE_RADIAL_UNIFORMS  "uniform sampler2D gradientTexture;" JUCE_DECLARE_MATRIX_UNIFORM
    #define JUCE_MATRIX_TIMES_FRAGCOORD   "(mat2 (matrix[0], matrix[3], matrix[1], matrix[4]) * pixelPos" \
                                          " + vec2 (matrix[2], matrix[5]))"
    #define JUCE_GET_TEXTURE_COLOUR       "(frontColour.a * texture2D (gradientTexture, vec2 (gradientPos, 0.5)))"

    struct RadialGradientProgram final : public ShaderBase
    {
        RadialGradientProgram (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_VARYING_PIXELPOS
                          JUCE_DECLARE_RADIAL_UNIFORMS JUCE_DECLARE_VARYING_COLOUR
                          "void main()"
                          "{"
                            "#mediump# float gradientPos = length (" JUCE_MATRIX_TIMES_FRAGCOORD ");"
                            "gl_FragColor = " JUCE_GET_TEXTURE_COLOUR ";"
                          "}"),
              gradientParams (program)
        {}

        RadialGradientParams gradientParams;
    };

    struct RadialGradientMaskedProgram final : public ShaderBase
    {
        RadialGradientMaskedProgram (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_VARYING_PIXELPOS
                          JUCE_DECLARE_RADIAL_UNIFORMS JUCE_DECLARE_VARYING_COLOUR
                          JUCE_DECLARE_MASK_UNIFORMS
                          "void main()"
                          "{"
                            "#mediump# float gradientPos = length (" JUCE_MATRIX_TIMES_FRAGCOORD ");"
                            "gl_FragColor = " JUCE_GET_TEXTURE_COLOUR " * " JUCE_GET_MASK_ALPHA ";"
                          "}"),
              gradientParams (program),
              maskParams (program)
        {}

        RadialGradientParams gradientParams;
        MaskedShaderParams maskParams;
    };

    //==============================================================================
    struct LinearGradientParams
    {
        LinearGradientParams (OpenGLShaderProgram& program)
            : gradientTexture (program, "gradientTexture"),
              gradientInfo (program, "gradientInfo")
        {}

        OpenGLShaderProgram::Uniform gradientTexture, gradientInfo;
    };

    #define JUCE_DECLARE_LINEAR_UNIFORMS  "uniform sampler2D gradientTexture;" \
                                          "uniform #mediump# vec4 gradientInfo;" \
                                          JUCE_DECLARE_VARYING_COLOUR JUCE_DECLARE_VARYING_PIXELPOS
    #define JUCE_CALC_LINEAR_GRAD_POS1    "#mediump# float gradientPos = (pixelPos.y - (gradientInfo.y + (gradientInfo.z * (pixelPos.x - gradientInfo.x)))) / gradientInfo.w;"
    #define JUCE_CALC_LINEAR_GRAD_POS2    "#mediump# float gradientPos = (pixelPos.x - (gradientInfo.x + (gradientInfo.z * (pixelPos.y - gradientInfo.y)))) / gradientInfo.w;"

    struct LinearGradient1Program final : public ShaderBase
    {
        LinearGradient1Program (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_LINEAR_UNIFORMS  // gradientInfo: x = x1, y = y1, z = (y2 - y1) / (x2 - x1), w = length
                          "void main()"
                          "{"
                            JUCE_CALC_LINEAR_GRAD_POS1
                            "gl_FragColor = " JUCE_GET_TEXTURE_COLOUR ";"
                          "}"),
              gradientParams (program)
        {}

        LinearGradientParams gradientParams;
    };

    struct LinearGradient1MaskedProgram final : public ShaderBase
    {
        LinearGradient1MaskedProgram (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_LINEAR_UNIFORMS  // gradientInfo: x = x1, y = y1, z = (y2 - y1) / (x2 - x1), w = length
                          JUCE_DECLARE_MASK_UNIFORMS
                          "void main()"
                          "{"
                            JUCE_CALC_LINEAR_GRAD_POS1
                            "gl_FragColor = " JUCE_GET_TEXTURE_COLOUR " * " JUCE_GET_MASK_ALPHA ";"
                          "}"),
              gradientParams (program),
              maskParams (program)
        {}

        LinearGradientParams gradientParams;
        MaskedShaderParams maskParams;
    };

    struct LinearGradient2Program final : public ShaderBase
    {
        LinearGradient2Program (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_LINEAR_UNIFORMS  // gradientInfo: x = x1, y = y1, z = (x2 - x1) / (y2 - y1), y = y1, w = length
                          "void main()"
                          "{"
                            JUCE_CALC_LINEAR_GRAD_POS2
                            "gl_FragColor = " JUCE_GET_TEXTURE_COLOUR ";"
                          "}"),
              gradientParams (program)
        {}

        LinearGradientParams gradientParams;
    };

    struct LinearGradient2MaskedProgram final : public ShaderBase
    {
        LinearGradient2MaskedProgram (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_LINEAR_UNIFORMS  // gradientInfo: x = x1, y = y1, z = (x2 - x1) / (y2 - y1), y = y1, w = length
                          JUCE_DECLARE_MASK_UNIFORMS
                          "void main()"
                          "{"
                            JUCE_CALC_LINEAR_GRAD_POS2
                            "gl_FragColor = " JUCE_GET_TEXTURE_COLOUR " * " JUCE_GET_MASK_ALPHA ";"
                          "}"),
              gradientParams (program),
              maskParams (program)
        {}

        LinearGradientParams gradientParams;
        MaskedShaderParams maskParams;
    };

    //==============================================================================
    struct ImageParams
    {
        ImageParams (OpenGLShaderProgram& program)
            : imageTexture (program, "imageTexture"),
              matrix (program, "matrix"),
              imageLimits (program, "imageLimits")
        {}

        void setMatrix (const AffineTransform& trans, const TextureInfo& textureInfo,
                        float targetX, float targetY, bool applyNpotTilingWorkaround) const
        {
            const auto imageWidth = textureInfo.imageWidth;
            const auto imageHeight = textureInfo.imageHeight;
            auto fullWidthProportion = textureInfo.fullWidthProportion;
            auto fullHeightProportion = textureInfo.fullHeightProportion;

            auto t = trans.translated (-targetX, -targetY)
                          .inverted().scaled (fullWidthProportion  / (float) imageWidth,
                                              fullHeightProportion / (float) imageHeight);

            const GLfloat m[] = { t.mat00, t.mat01, t.mat02, t.mat10, t.mat11, t.mat12 };
            matrix.set (m, 6);

            if (applyNpotTilingWorkaround)
            {
                fullWidthProportion  -= 0.5f / (float) imageWidth;
                fullHeightProportion -= 0.5f / (float) imageHeight;
            }

            imageLimits.set (fullWidthProportion, fullHeightProportion);
        }

        OpenGLShaderProgram::Uniform imageTexture, matrix, imageLimits;
    };

    #define JUCE_DECLARE_IMAGE_UNIFORMS "uniform sampler2D imageTexture;" \
                                        "uniform #mediump# vec2 imageLimits;" \
                                        JUCE_DECLARE_MATRIX_UNIFORM JUCE_DECLARE_VARYING_COLOUR JUCE_DECLARE_VARYING_PIXELPOS
    #define JUCE_GET_IMAGE_PIXEL        "texture2D (imageTexture, vec2 (texturePos.x, 1.0 - texturePos.y))"
    #define JUCE_CLAMP_TEXTURE_COORD    "#highp# vec2 texturePos = clamp (" JUCE_MATRIX_TIMES_FRAGCOORD ", vec2 (0, 0), imageLimits);"
    #define JUCE_MOD_TEXTURE_COORD      "#highp# vec2 texturePos = mod (" JUCE_MATRIX_TIMES_FRAGCOORD ", imageLimits);"

    struct ImageProgram final : public ShaderBase
    {
        ImageProgram (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_VARYING_COLOUR
                          "uniform sampler2D imageTexture;"
                          "varying #highp# vec2 texturePos;"
                          "void main()"
                          "{"
                            "gl_FragColor = frontColour.a * " JUCE_GET_IMAGE_PIXEL ";"
                          "}",
                          "uniform #mediump# vec2 imageLimits;"
                          JUCE_DECLARE_MATRIX_UNIFORM
                          "attribute vec2 position;"
                          "attribute vec4 colour;"
                          "uniform vec4 screenBounds;"
                          "varying #mediump# vec4 frontColour;"
                          "varying #highp# vec2 texturePos;"
                          "void main()"
                          "{"
                            "frontColour = colour;"
                            "vec2 adjustedPos = position - screenBounds.xy;"
                            "vec2 pixelPos = adjustedPos;"
                            "texturePos = clamp (" JUCE_MATRIX_TIMES_FRAGCOORD ", vec2 (0, 0), imageLimits);"
                            "vec2 scaledPos = adjustedPos / screenBounds.zw;"
                            "gl_Position = vec4 (scaledPos.x - 1.0, 1.0 - scaledPos.y, 0, 1.0);"
                          "}"),
              imageParams (program)
        {}

        ImageParams imageParams;
    };

    struct ImageMaskedProgram final : public ShaderBase
    {
        ImageMaskedProgram (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_IMAGE_UNIFORMS JUCE_DECLARE_MASK_UNIFORMS
                          "void main()"
                          "{"
                            JUCE_CLAMP_TEXTURE_COORD
                            "gl_FragColor = frontColour.a * " JUCE_GET_IMAGE_PIXEL " * " JUCE_GET_MASK_ALPHA ";"
                          "}"),
              imageParams (program),
              maskParams (program)
        {}

        ImageParams imageParams;
        MaskedShaderParams maskParams;
    };

    struct TiledImageProgram final : public ShaderBase
    {
        TiledImageProgram (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_IMAGE_UNIFORMS
                          "void main()"
                          "{"
                            JUCE_MOD_TEXTURE_COORD
                            "gl_FragColor = frontColour.a * " JUCE_GET_IMAGE_PIXEL ";"
                          "}"),
              imageParams (program)
        {}

        ImageParams imageParams;
    };

    struct TiledImageMaskedProgram final : public ShaderBase
    {
        TiledImageMaskedProgram (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_IMAGE_UNIFORMS JUCE_DECLARE_MASK_UNIFORMS
                          "void main()"
                          "{"
                            JUCE_MOD_TEXTURE_COORD
                            "gl_FragColor = frontColour.a * " JUCE_GET_IMAGE_PIXEL " * " JUCE_GET_MASK_ALPHA ";"
                          "}"),
              imageParams (program),
              maskParams (program)
        {}

        ImageParams imageParams;
        MaskedShaderParams maskParams;
    };

    struct CopyTextureProgram final : public ShaderBase
    {
        CopyTextureProgram (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_IMAGE_UNIFORMS
                          "void main()"
                          "{"
                            JUCE_MOD_TEXTURE_COORD
                            "gl_FragColor = frontColour.a * " JUCE_GET_IMAGE_PIXEL ";"
                          "}"),
              imageParams (program)
        {}

        ImageParams imageParams;
    };

    struct MaskTextureProgram final : public ShaderBase
    {
        MaskTextureProgram (OpenGLContext& context)
            : ShaderBase (context, JUCE_DECLARE_IMAGE_UNIFORMS
                          "void main()"
                          "{"
                            "#highp# vec2 texturePos = " JUCE_MATRIX_TIMES_FRAGCOORD ";"
                            "#highp# float roundingError = 0.00001;"
                            "if (texturePos.x >= -roundingError"
                                 "&& texturePos.y >= -roundingError"
                                 "&& texturePos.x <= imageLimits.x + roundingError"
                                 "&& texturePos.y <= imageLimits.y + roundingError)"
                             "gl_FragColor = frontColour * " JUCE_GET_IMAGE_PIXEL ".a;"
                            "else "
                             "gl_FragColor = vec4 (0, 0, 0, 0);"
                          "}"),
              imageParams (program)
        {}

        ImageParams imageParams;
    };

    SolidColourProgram solidColourProgram;
    SolidColourMaskedProgram solidColourMasked;
    RadialGradientProgram radialGradient;
    RadialGradientMaskedProgram radialGradientMasked;
    LinearGradient1Program linearGradient1;
    LinearGradient1MaskedProgram linearGradient1Masked;
    LinearGradient2Program linearGradient2;
    LinearGradient2MaskedProgram linearGradient2Masked;
    ImageProgram image;
    ImageMaskedProgram imageMasked;
    TiledImageProgram tiledImage;
    TiledImageMaskedProgram tiledImageMasked;
    CopyTextureProgram copyTexture;
    MaskTextureProgram maskTexture;
};

//==============================================================================
struct TraitsVAO
{
    /*  Returns true if the context requires a non-zero vertex array object (VAO) to be bound.

        If the context is a compatibility context, we can just pretend that VAOs don't exist,
        and use the default VAO all the time instead. This provides a more consistent experience
        in user code, which might make calls (like glVertexPointer()) that only work when VAO 0 is
        bound in OpenGL 3.2+.
    */
    static bool shouldUseCustomVAO()
    {
        return ! OpenGLHelpers::isOpenGLES() && getOpenGLProfile() == OpenGLProfile::core;
    }

    static constexpr auto value = GL_VERTEX_ARRAY_BINDING;
    static constexpr auto& gen = glGenVertexArrays;
    static constexpr auto& del = glDeleteVertexArrays;
    template <typename T>
    static void bind (T x) { gl::glBindVertexArray (static_cast<GLuint> (x)); }
    static constexpr auto predicate = shouldUseCustomVAO;
};

struct TraitsArrayBuffer
{
    static constexpr auto value = GL_ARRAY_BUFFER_BINDING;
    static constexpr auto& gen = glGenBuffers;
    static constexpr auto& del = glDeleteBuffers;
    template <typename T>
    static void bind (T x) { gl::glBindBuffer (GL_ARRAY_BUFFER, static_cast<GLuint> (x)); }
    static bool predicate() { return true; }
};

struct TraitsElementArrayBuffer
{
    static constexpr auto value = GL_ELEMENT_ARRAY_BUFFER_BINDING;
    static constexpr auto& gen = glGenBuffers;
    static constexpr auto& del = glDeleteBuffers;
    template <typename T>
    static void bind (T x) { gl::glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, static_cast<GLuint> (x)); }
    static bool predicate() { return true; }
};

template <typename Traits>
class SavedBinding
{
public:
    SavedBinding() = default;

    ~SavedBinding()
    {
        if (! Traits::predicate())
            return;

        Traits::bind (values.previous);
        Traits::del (1, &values.current);
    }

    void bind() const { Traits::bind (values.current); }

    JUCE_DECLARE_NON_COPYABLE (SavedBinding)
    JUCE_DECLARE_NON_MOVEABLE (SavedBinding)

private:
    struct Values
    {
        GLint previous{};
        GLuint current{};
    };

    static Values getInitialValues()
    {
        if (! Traits::predicate())
            return Values{};

        GLint previous{};
        glGetIntegerv (Traits::value, &previous);

        GLuint current{};
        Traits::gen (1, &current);
        Traits::bind (current);

        return Values { previous, current };
    }

    Values values = getInitialValues();
};

//==============================================================================
struct StateHelpers
{
    struct BlendingMode
    {
        BlendingMode() noexcept {}

        ~BlendingMode()
        {
            glBlendFuncSeparate (prevSrcRGB, prevDstRGB, prevSrcAlpha, prevDstAlpha);

            if ((bool) glIsEnabled (GL_BLEND) == prevBlendEnabled)
                return;

            if (prevBlendEnabled)
                glEnable (GL_BLEND);
            else
                glDisable (GL_BLEND);

        }

        void resync() noexcept
        {
            glDisable (GL_BLEND);
            srcFunction = dstFunction = 0;
        }

        template <typename QuadQueueType>
        void setBlendFunc (QuadQueueType& quadQueue, GLenum src, GLenum dst)
        {
            if (! blendingEnabled)
            {
                quadQueue.flush();
                blendingEnabled = true;
                glEnable (GL_BLEND);
            }

            if (srcFunction != src || dstFunction != dst)
            {
                quadQueue.flush();
                srcFunction = src;
                dstFunction = dst;
                glBlendFunc (src, dst);
            }
        }

        template <typename QuadQueueType>
        void disableBlend (QuadQueueType& quadQueue) noexcept
        {
            if (blendingEnabled)
            {
                quadQueue.flush();
                blendingEnabled = false;
                glDisable (GL_BLEND);
            }
        }

        template <typename QuadQueueType>
        void setBlendMode (QuadQueueType& quadQueue, BlendMode mode) noexcept
        {
            switch (mode)
            {
                case BlendMode::source:
                    setBlendFunc (quadQueue, GL_ONE, GL_ZERO);
                    return;

                case BlendMode::sourceOver:
                    setBlendFunc (quadQueue, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
                    return;

                case BlendMode::destinationIn:
                    setBlendFunc (quadQueue, GL_ZERO, GL_SRC_ALPHA);
                    return;

                case BlendMode::destinationOut:
                    setBlendFunc (quadQueue, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
                    return;
            }

            jassertfalse;
            setBlendFunc (quadQueue, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
        }

    private:
        static GLenum getBlendEnum (GLenum kind)
        {
            GLint result{};
            glGetIntegerv (kind, &result);
            return static_cast<GLenum> (result);
        }

        GLenum srcFunction = 0, dstFunction = 0;
        GLenum prevSrcAlpha = getBlendEnum (GL_BLEND_SRC_ALPHA);
        GLenum prevSrcRGB   = getBlendEnum (GL_BLEND_SRC_RGB);
        GLenum prevDstAlpha = getBlendEnum (GL_BLEND_DST_ALPHA);
        GLenum prevDstRGB   = getBlendEnum (GL_BLEND_DST_RGB);
        bool blendingEnabled = false;
        bool prevBlendEnabled = glIsEnabled (GL_BLEND);
    };

    //==============================================================================
    template <typename QuadQueueType>
    struct EdgeTableRenderer
    {
        EdgeTableRenderer (QuadQueueType& q, PixelARGB c) noexcept
            : quadQueue (q), colour (c)
        {}

        void setEdgeTableYPos (int y) noexcept
        {
            currentY = y;
        }

        void handleEdgeTablePixel (int x, int alphaLevel) noexcept
        {
            auto c = colour;
            c.multiplyAlpha (alphaLevel);
            quadQueue.add (x, currentY, 1, 1, c);
        }

        void handleEdgeTablePixelFull (int x) noexcept
        {
            quadQueue.add (x, currentY, 1, 1, colour);
        }

        void handleEdgeTableLine (int x, int width, int alphaLevel) noexcept
        {
            auto c = colour;
            c.multiplyAlpha (alphaLevel);
            quadQueue.add (x, currentY, width, 1, c);
        }

        void handleEdgeTableLineFull (int x, int width) noexcept
        {
            quadQueue.add (x, currentY, width, 1, colour);
        }

        void handleEdgeTableRectangle (int x, int y, int width, int height, int alphaLevel) noexcept
        {
            auto c = colour;
            c.multiplyAlpha (alphaLevel);
            quadQueue.add (x, y, width, height, c);
        }

        void handleEdgeTableRectangleFull (int x, int y, int width, int height) noexcept
        {
            quadQueue.add (x, y, width, height, colour);
        }

    private:
        QuadQueueType& quadQueue;
        const PixelARGB colour;
        int currentY;

        JUCE_DECLARE_NON_COPYABLE (EdgeTableRenderer)
    };

    template <typename QuadQueueType>
    struct FloatRectangleRenderer
    {
        FloatRectangleRenderer (QuadQueueType& q, PixelARGB c) noexcept
            : quadQueue (q), colour (c)
        {}

        void operator() (int x, int y, int w, int h, int alpha) noexcept
        {
            if (w > 0 && h > 0)
            {
                PixelARGB c (colour);
                c.multiplyAlpha (alpha);
                quadQueue.add (x, y, w, h, c);
            }
        }

    private:
        QuadQueueType& quadQueue;
        const PixelARGB colour;

        JUCE_DECLARE_NON_COPYABLE (FloatRectangleRenderer)
    };

    //==============================================================================
    struct ActiveTextures
    {
        explicit ActiveTextures (const OpenGLContext& c) noexcept
            : needsToEnableTexture (c.getProfile() == OpenGLProfile::compatibility)
        {
        }

        void clear() noexcept
        {
            zeromem (currentTextureID, sizeof (currentTextureID));
        }

        template <typename QuadQueueType>
        void setTexturesEnabled (QuadQueueType& quadQueue, int textureIndexMask) noexcept
        {
            if (texturesEnabled != textureIndexMask)
            {
                quadQueue.flush();

                for (int i = numTextures; --i >= 0;)
                {
                    if ((texturesEnabled & (1 << i)) != (textureIndexMask & (1 << i)))
                    {
                        setActiveTexture (i);
                        JUCE_CHECK_OPENGL_ERROR

                        const auto thisTextureEnabled = (textureIndexMask & (1 << i)) != 0;

                        if (! thisTextureEnabled)
                            currentTextureID[i] = 0;

                       #if ! JUCE_ANDROID
                        if (needsToEnableTexture)
                        {
                            if (thisTextureEnabled)
                                glEnable (GL_TEXTURE_2D);
                            else
                                glDisable (GL_TEXTURE_2D);

                            JUCE_CHECK_OPENGL_ERROR
                        }
                       #endif
                    }
                }

                texturesEnabled = textureIndexMask;
            }
        }

        template <typename QuadQueueType>
        void disableTextures (QuadQueueType& quadQueue) noexcept
        {
            setTexturesEnabled (quadQueue, 0);
        }

        template <typename QuadQueueType>
        void setSingleTextureMode (QuadQueueType& quadQueue) noexcept
        {
            setTexturesEnabled (quadQueue, 1);
            setActiveTexture (0);
        }

        template <typename QuadQueueType>
        void setTwoTextureMode (QuadQueueType& quadQueue, GLuint texture1, GLuint texture2)
        {
            JUCE_CHECK_OPENGL_ERROR
            setTexturesEnabled (quadQueue, 3);

            if (currentActiveTexture == 0)
            {
                bindTexture (texture1);
                setActiveTexture (1);
                bindTexture (texture2);
            }
            else
            {
                setActiveTexture (1);
                bindTexture (texture2);
                setActiveTexture (0);
                bindTexture (texture1);
            }

            JUCE_CHECK_OPENGL_ERROR
        }

        void setActiveTexture (int index) noexcept
        {
            if (currentActiveTexture != index)
            {
                currentActiveTexture = index;
                glActiveTexture (GL_TEXTURE0 + (GLenum) index);
                JUCE_CHECK_OPENGL_ERROR
            }
        }

        void bindTexture (GLuint textureID) noexcept
        {
            if (currentActiveTexture < 0 || numTextures <= currentActiveTexture)
            {
                jassertfalse;
                return;
            }

            if (currentTextureID[currentActiveTexture] != textureID)
            {
                currentTextureID[currentActiveTexture] = textureID;
                glBindTexture (GL_TEXTURE_2D, textureID);
                JUCE_CHECK_OPENGL_ERROR
            }
           #if JUCE_DEBUG
            else
            {
                GLint t = 0;
                glGetIntegerv (GL_TEXTURE_BINDING_2D, &t);
                jassert (t == (GLint) textureID);
            }
           #endif
        }

    private:
        static constexpr auto numTextures = 3;
        GLuint currentTextureID[numTextures];
        int texturesEnabled = 0, currentActiveTexture = -1;
        bool needsToEnableTexture;

        JUCE_DECLARE_NON_COPYABLE (ActiveTextures)
        JUCE_DECLARE_NON_MOVEABLE (ActiveTextures)
    };

    //==============================================================================
    struct TextureCache
    {
        TextureCache() = default;

        OpenGLTexture* getTexture (ActiveTextures& activeTextures, int w, int h)
        {
            if (textures.size() < numTexturesToCache)
            {
                activeTextures.clear();
                return new OpenGLTexture();
            }

            for (int i = 0; i < numTexturesToCache - 2; ++i)
            {
                auto* t = textures.getUnchecked (i);

                if (t->getWidth() == w && t->getHeight() == h)
                    return textures.removeAndReturn (i);
            }

            return textures.removeAndReturn (0);
        }

        void resetGradient() noexcept
        {
            gradientNeedsRefresh = true;
        }

        void bindTextureForGradient (ActiveTextures& activeTextures, const ColourGradient& gradient)
        {
            if (gradientNeedsRefresh)
            {
                gradientNeedsRefresh = false;

                if (gradientTextures.size() < numGradientTexturesToCache)
                {
                    activeGradientIndex = gradientTextures.size();
                    activeTextures.clear();
                    gradientTextures.add (new OpenGLTexture());
                }
                else
                {
                    activeGradientIndex = (activeGradientIndex + 1) % numGradientTexturesToCache;
                }

                JUCE_CHECK_OPENGL_ERROR;
                PixelARGB lookup[gradientTextureSize];
                gradient.createLookupTable (lookup);
                gradientTextures.getUnchecked (activeGradientIndex)->loadARGB (lookup, gradientTextureSize, 1);
            }

            activeTextures.bindTexture (gradientTextures.getUnchecked (activeGradientIndex)->getTextureID());
        }

        enum { gradientTextureSize = 256 };

    private:
        enum { numTexturesToCache = 8, numGradientTexturesToCache = 10 };
        OwnedArray<OpenGLTexture> textures, gradientTextures;
        int activeGradientIndex = 0;
        bool gradientNeedsRefresh = true;
    };

    //==============================================================================
    struct ShaderQuadQueue
    {
        ShaderQuadQueue (const OpenGLContext& c) noexcept  : context (c)
        {}

        ~ShaderQuadQueue() noexcept
        {
            static_assert (sizeof (VertexInfo) == 8, "Sanity check VertexInfo size");
        }

        void initialise() noexcept
        {
            JUCE_CHECK_OPENGL_ERROR

           #if JUCE_ANDROID || JUCE_IOS
            int numQuads = maxNumQuads;
           #else
            GLint maxIndices = 0;
            glGetIntegerv (GL_MAX_ELEMENTS_INDICES, &maxIndices);
            auto numQuads = jmin ((int) maxNumQuads, (int) maxIndices / 6);
            maxVertices = numQuads * 4 - 4;
           #endif

            for (int i = 0, v = 0; i < numQuads * 6; i += 6, v += 4)
            {
                indexData[i] = (GLushort) v;
                indexData[i + 1] = indexData[i + 3] = (GLushort) (v + 1);
                indexData[i + 2] = indexData[i + 4] = (GLushort) (v + 2);
                indexData[i + 5] = (GLushort) (v + 3);
            }

            savedElementArrayBuffer.bind();
            context.extensions.glBufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof (indexData), indexData, GL_STATIC_DRAW);

            savedArrayBuffer.bind();
            context.extensions.glBufferData (GL_ARRAY_BUFFER, sizeof (vertexData), vertexData, GL_STREAM_DRAW);
            JUCE_CHECK_OPENGL_ERROR
        }

        void add (int x, int y, int w, int h, PixelARGB colour) noexcept
        {
            jassert (w > 0 && h > 0);

            auto* v = vertexData + numVertices;
            v[0].x = v[2].x = (GLshort) x;
            v[0].y = v[1].y = (GLshort) y;
            v[1].x = v[3].x = (GLshort) (x + w);
            v[2].y = v[3].y = (GLshort) (y + h);

           #if JUCE_BIG_ENDIAN
            auto rgba = (GLuint) ((colour.getRed() << 24) | (colour.getGreen() << 16)
                                | (colour.getBlue() << 8) |  colour.getAlpha());
           #else
            auto rgba = (GLuint) ((colour.getAlpha() << 24) | (colour.getBlue() << 16)
                                | (colour.getGreen() << 8) |  colour.getRed());
           #endif

            v[0].colour = rgba;
            v[1].colour = rgba;
            v[2].colour = rgba;
            v[3].colour = rgba;

            numVertices += 4;

            if (numVertices > maxVertices)
                draw();
        }

        void add (Rectangle<int> r, PixelARGB colour) noexcept
        {
            add (r.getX(), r.getY(), r.getWidth(), r.getHeight(), colour);
        }

        void add (Rectangle<float> r, PixelARGB colour) noexcept
        {
            FloatRectangleRenderer<ShaderQuadQueue> frr (*this, colour);
            RenderingHelpers::FloatRectangleRasterisingInfo (r).iterate (frr);
        }

        void add (const RectangleList<int>& list, PixelARGB colour) noexcept
        {
            for (auto& i : list)
                add (i, colour);
        }

        void add (const RectangleList<int>& list, Rectangle<int> clip, PixelARGB colour) noexcept
        {
            for (auto& i : list)
            {
                auto r = i.getIntersection (clip);

                if (! r.isEmpty())
                    add (r, colour);
            }
        }

        template <typename IteratorType>
        void add (const IteratorType& et, PixelARGB colour)
        {
            EdgeTableRenderer<ShaderQuadQueue> etr (*this, colour);
            et.iterate (etr);
        }

        void flush() noexcept
        {
            if (numVertices > 0)
                draw();
        }

    private:
        struct VertexInfo
        {
            GLshort x, y;
            GLuint colour;
        };

        enum { maxNumQuads = 256 };

        SavedBinding<TraitsArrayBuffer> savedArrayBuffer;
        SavedBinding<TraitsElementArrayBuffer> savedElementArrayBuffer;
        VertexInfo vertexData[maxNumQuads * 4];
        GLushort indexData[maxNumQuads * 6];
        const OpenGLContext& context;
        int numVertices = 0;

       #if JUCE_ANDROID || JUCE_IOS
        enum { maxVertices = maxNumQuads * 4 - 4 };
       #else
        int maxVertices = 0;
       #endif

        void draw() noexcept
        {
            context.extensions.glBufferSubData (GL_ARRAY_BUFFER, 0, (GLsizeiptr) ((size_t) numVertices * sizeof (VertexInfo)), vertexData);
            // NB: If you get a random crash in here and are running in a Parallels VM, it seems to be a bug in
            // their driver. Can't find a workaround unfortunately.
            glDrawElements (GL_TRIANGLES, (numVertices * 3) / 2, GL_UNSIGNED_SHORT, nullptr);
            JUCE_CHECK_OPENGL_ERROR
            numVertices = 0;
        }

        JUCE_DECLARE_NON_COPYABLE (ShaderQuadQueue)
    };

    //==============================================================================
    struct CurrentShader
    {
        explicit CurrentShader (OpenGLContext& c)
            : context (c)
        {
        }

        ~CurrentShader()
        {
            jassert (activeShader == nullptr);

            if (initialShader == nullptr)
                return;

            initialShader->program.use();

            // If there are multiple VAOs, then normally binding the previous VAO would also restore
            // the shader attributes that were last used with that VAO. If there's just a single
            // global VAO, we need to reset the attributes manually.
            if (! TraitsVAO::shouldUseCustomVAO())
                initialShader->bindAttributes();

            if (initialShader->onShaderActivated)
                initialShader->onShaderActivated (initialShader->program);

            initialShader->set2DBounds (initialBounds);
        }

        void setShader (Rectangle<int> bounds, ShaderQuadQueue& quadQueue, ShaderPrograms::ShaderBase& shader)
        {
            if (activeShader != &shader)
            {
                clearShader (quadQueue);

                activeShader = &shader;
                shader.program.use();
                shader.bindAttributes();

                if (shader.onShaderActivated)
                    shader.onShaderActivated (shader.program);

                currentBounds = bounds;
                shader.set2DBounds (bounds.toFloat());

                JUCE_CHECK_OPENGL_ERROR
            }
            else if (bounds != currentBounds)
            {
                currentBounds = bounds;
                shader.set2DBounds (bounds.toFloat());
            }
        }

        void setShader (Target& target, ShaderQuadQueue& quadQueue, ShaderPrograms::ShaderBase& shader)
        {
            setShader (target.bounds, quadQueue, shader);
        }

        void clearShader (ShaderQuadQueue& quadQueue)
        {
            if (activeShader != nullptr)
            {
                quadQueue.flush();
                activeShader->unbindAttributes();
                activeShader = nullptr;
                context.extensions.glUseProgram (0);
            }
        }

        static constexpr auto programValueID = "GraphicsContextPrograms";

        OpenGLContext& context;
        ShaderPrograms::Ptr programs = std::invoke ([&]
        {
            if (ShaderPrograms::Ptr result { static_cast<ShaderPrograms*> (context.getAssociatedObject (programValueID)) })
                return result;

            ShaderPrograms::Ptr newPrograms = new ShaderPrograms (context);
            context.setAssociatedObject (programValueID, newPrograms.get());
            return newPrograms;
        });

    private:
        // We store the original shader and bounds so that we can restore the previous
        // when the CurrentShader is destroyed.
        // Note that we do *not* set the active shader and bounds to their previous values.
        // If a CurrentShader has been constructed, there's a good chance that a new VAO has
        // also been constructed, in which case we'll need to call bindAttributes() the first
        // time that a shader is used in this new VAO.

        ShaderPrograms::ShaderBase* initialShader = programs->findActiveShader();
        ShaderPrograms::ShaderBase* activeShader = nullptr;
        Rectangle<float> initialBounds = initialShader != nullptr
                                       ? initialShader->get2DBounds()
                                       : Rectangle<float>{};
        Rectangle<int> currentBounds;

        CurrentShader& operator= (const CurrentShader&);
    };
};

//==============================================================================
class ViewportRestorer
{
public:
    ViewportRestorer()
    {
        glGetIntegerv (GL_VIEWPORT, bounds);
    }

    ~ViewportRestorer()
    {
        glViewport (bounds[0], bounds[1], bounds[2], bounds[3]);
    }

private:
    GLint bounds[4];
};

//==============================================================================
struct GLState : private ImagePixelData::Listener
{
    explicit GLState (const Target& t) noexcept
        : target (t),
          activeTextures (t.context),
          currentShader (t.context),
          shaderQuadQueue (t.context),
          previousFrameBufferTarget (OpenGLFrameBuffer::getCurrentFrameBufferTarget())
    {
        // This object can only be created and used when the current thread has an active OpenGL context.
        jassert (OpenGLHelpers::isContextActive());

        JUCE_CHECK_OPENGL_ERROR
        target.makeActive();
        blendMode.resync();
        JUCE_CHECK_OPENGL_ERROR
        activeTextures.clear();
        shaderQuadQueue.initialise();
        cachedImageList = CachedImageList::get (t.context);
        JUCE_CHECK_OPENGL_ERROR
    }

    ~GLState() override
    {
        flush();

        for (auto* pixelData : observedPixelData)
        {
            pixelData->listeners.remove (this);
        }

        target.context.extensions.glBindFramebuffer (GL_FRAMEBUFFER, previousFrameBufferTarget);
    }

    void flush()
    {
        shaderQuadQueue.flush();
        currentShader.clearShader (shaderQuadQueue);
        JUCE_CHECK_OPENGL_ERROR
    }

    void setShader (ShaderPrograms::ShaderBase& shader)
    {
        currentShader.setShader (target, shaderQuadQueue, shader);
        JUCE_CHECK_OPENGL_ERROR
    }

    void setShaderForGradientFill (const ColourGradient& g, const AffineTransform& transform,
                                   int maskTextureID, const Rectangle<int>* maskArea)
    {
        JUCE_CHECK_OPENGL_ERROR
        activeTextures.disableTextures (shaderQuadQueue);
        blendMode.setBlendMode (shaderQuadQueue, BlendMode::sourceOver);
        JUCE_CHECK_OPENGL_ERROR

        if (maskArea != nullptr)
        {
            activeTextures.setTexturesEnabled (shaderQuadQueue, 3);
            activeTextures.setActiveTexture (1);
            activeTextures.bindTexture ((GLuint) maskTextureID);
            activeTextures.setActiveTexture (0);
            textureCache.bindTextureForGradient (activeTextures, g);
        }
        else
        {
            activeTextures.setSingleTextureMode (shaderQuadQueue);
            textureCache.bindTextureForGradient (activeTextures, g);
        }

        auto t = transform.translated (0.5f - (float) target.bounds.getX(),
                                       0.5f - (float) target.bounds.getY());

        auto programs = currentShader.programs;
        const ShaderPrograms::MaskedShaderParams* maskParams = nullptr;

        if (g.isRadial)
        {
            detail::RadialGradientView gv { &g };

            // This shader is only handling the simple radial case where the start and end circles
            // are concentric.
            const auto c1 = gv.getStartCircle().c;
            const auto c2 = c1 + Point<float> { gv.getEndCircle().r, 0 };
            const auto p1 = c1.transformedBy (t);
            const auto p2 = c2.transformedBy (t);
            const auto p3 = Point<float> (c1.x + (c2.y - c1.y),
                                          c1.y - (c2.x - c1.x)).transformedBy (t);

            ShaderPrograms::RadialGradientParams* gradientParams;

            if (maskArea == nullptr)
            {
                setShader (programs->radialGradient);
                gradientParams = &programs->radialGradient.gradientParams;
            }
            else
            {
                setShader (programs->radialGradientMasked);
                gradientParams = &programs->radialGradientMasked.gradientParams;
                maskParams = &programs->radialGradientMasked.maskParams;
            }

            gradientParams->setMatrix (p1, p2, p3);
        }
        else
        {
            auto p1 = g.point1.transformedBy (t);
            const auto p2 = g.point2.transformedBy (t);
            const auto p3 = Point<float> (g.point1.x + (g.point2.y - g.point1.y),
                                          g.point1.y - (g.point2.x - g.point1.x)).transformedBy (t);

            p1 = Line<float> (p1, p3).findNearestPointTo (p2);
            const Point<float> delta (p2.x - p1.x, p1.y - p2.y);
            const ShaderPrograms::LinearGradientParams* gradientParams;
            float grad, length;

            if (std::abs (delta.x) < std::abs (delta.y))
            {
                if (maskArea == nullptr)
                {
                    setShader (programs->linearGradient1);
                    gradientParams = &(programs->linearGradient1.gradientParams);
                }
                else
                {
                    setShader (programs->linearGradient1Masked);
                    gradientParams = &(programs->linearGradient1Masked.gradientParams);
                    maskParams = &programs->linearGradient1Masked.maskParams;
                }

                grad = delta.x / delta.y;
                length = (p2.y - grad * p2.x) - (p1.y - grad * p1.x);
            }
            else
            {
                if (maskArea == nullptr)
                {
                    setShader (programs->linearGradient2);
                    gradientParams = &(programs->linearGradient2.gradientParams);
                }
                else
                {
                    setShader (programs->linearGradient2Masked);
                    gradientParams = &(programs->linearGradient2Masked.gradientParams);
                    maskParams = &programs->linearGradient2Masked.maskParams;
                }

                grad = delta.y / delta.x;
                length = (p2.x - grad * p2.y) - (p1.x - grad * p1.y);
            }

            gradientParams->gradientInfo.set (p1.x, p1.y, grad, length);
        }

        if (maskParams != nullptr)
            maskParams->setBounds (*maskArea, target, 1);

        JUCE_CHECK_OPENGL_ERROR
    }

    void setShaderForTiledImageFill (const Image& image,
                                     const AffineTransform& transform,
                                     int maskTextureID,
                                     const Rectangle<int>* maskArea,
                                     bool isTiledFill,
                                     BlendMode mode)
    {
        if (auto pd = image.getPixelData())
        {
            observedPixelData.insert (pd.get());
            pd->listeners.add (this);
        }

        const auto textureInfo = cachedImageList->getTextureFor (image);

        blendMode.setBlendMode (shaderQuadQueue, mode);
        auto programs = currentShader.programs;

        const ShaderPrograms::MaskedShaderParams* maskParams = nullptr;
        const ShaderPrograms::ImageParams* imageParams;

        if (maskArea != nullptr)
        {
            activeTextures.setTwoTextureMode (shaderQuadQueue, textureInfo.textureID, (GLuint) maskTextureID);

            if (isTiledFill)
            {
                setShader (programs->tiledImageMasked);
                imageParams = &programs->tiledImageMasked.imageParams;
                maskParams  = &programs->tiledImageMasked.maskParams;
            }
            else
            {
                setShader (programs->imageMasked);
                imageParams = &programs->imageMasked.imageParams;
                maskParams  = &programs->imageMasked.maskParams;
            }
        }
        else
        {
            activeTextures.setSingleTextureMode (shaderQuadQueue);
            activeTextures.bindTexture (textureInfo.textureID);

            if (isTiledFill)
            {
                setShader (programs->tiledImage);
                imageParams = &programs->tiledImage.imageParams;
            }
            else
            {
                setShader (programs->image);
                imageParams = &programs->image.imageParams;
            }
        }

        imageParams->setMatrix (transform,
                                textureInfo,
                                (float) target.bounds.getX(),
                                (float) target.bounds.getY(),
                                ! target.context.isTextureNpotSupported() && isTiledFill);

        if (maskParams != nullptr)
            maskParams->setBounds (*maskArea, target, 1);
    }

    Target target;

    StateHelpers::BlendingMode blendMode;
    StateHelpers::ActiveTextures activeTextures;
    StateHelpers::TextureCache textureCache;
    StateHelpers::CurrentShader currentShader;
    StateHelpers::ShaderQuadQueue shaderQuadQueue;

    CachedImageList::Ptr cachedImageList;

private:
    GLuint previousFrameBufferTarget;
    SavedBinding<TraitsVAO> savedVAOBinding;
    ViewportRestorer viewportRestorer;
    std::set<ImagePixelData*> observedPixelData;

    void imageDataBeingDeleted (ImagePixelData* ipd) override
    {
        observedPixelData.erase (ipd);
        activeTextures.bindTexture (0);
    }

    void imageDataChanged (ImagePixelData*) override {}

    JUCE_DECLARE_NON_COPYABLE (GLState)
    JUCE_DECLARE_NON_MOVEABLE (GLState)
};

//==============================================================================
struct SavedState final : public RenderingHelpers::SavedStateBase<SavedState>
{
    using BaseClass = SavedStateBase;

    SavedState (GLState* s)  : BaseClass (s->target.bounds), state (s)
    {}

    SavedState (const SavedState& other)
        : BaseClass (other), font (other.font), state (other.state),
          transparencyLayer (other.transparencyLayer),
          previousTarget (createCopyIfNotNull (other.previousTarget.get()))
    {}

    std::unique_ptr<SavedState> beginTransparencyLayer (float opacity)
    {
        auto s = std::make_unique<SavedState> (*this);

        if (clip != nullptr)
        {
            auto clipBounds = clip->getClipBounds();

            state->flush();
            s->transparencyLayer = Image (OpenGLImageType().create (Image::ARGB, clipBounds.getWidth(), clipBounds.getHeight(), true));
            s->previousTarget.reset (new Target (state->target));
            state->target = Target (state->target.context, *OpenGLImageType::getFrameBufferFrom (s->transparencyLayer), clipBounds.getPosition());
            s->transparencyLayerAlpha = opacity;
            s->cloneClipIfMultiplyReferenced();

            s->state->target.makeActive();
        }

        return s;
    }

    void endTransparencyLayer (SavedState& finishedLayerState)
    {
        if (clip != nullptr)
        {
            jassert (finishedLayerState.previousTarget != nullptr);

            state->flush();
            state->target = *finishedLayerState.previousTarget;
            finishedLayerState.previousTarget.reset();

            state->target.makeActive();
            auto clipBounds = clip->getClipBounds();

            clip->renderImageUntransformed (*this, finishedLayerState.transparencyLayer,
                                            (int) (finishedLayerState.transparencyLayerAlpha * 255.0f),
                                            clipBounds.getX(), clipBounds.getY(), false);

            state->activeTextures.bindTexture (0);
        }
    }

    Rectangle<int> getMaximumBounds() const     { return state->target.bounds; }

    void setFillType (const FillType& newFill)
    {
        BaseClass::setFillType (newFill);
        state->textureCache.resetGradient();
    }

    //==============================================================================
    template <typename IteratorType>
    void renderImageTransformed (IteratorType& iter, const Image& src, int alpha,
                                 const AffineTransform& trans, Graphics::ResamplingQuality, bool tiledFill) const
    {
        state->shaderQuadQueue.flush();

        state->setShaderForTiledImageFill (src,
                                           trans,
                                           0,
                                           nullptr,
                                           tiledFill,
                                           imageBlendMode);

        state->shaderQuadQueue.add (iter, PixelARGB ((uint8) alpha, (uint8) alpha, (uint8) alpha, (uint8) alpha));
        state->shaderQuadQueue.flush();

        state->currentShader.clearShader (state->shaderQuadQueue);
    }

    template <typename IteratorType>
    void renderImageUntransformed (IteratorType& iter, const Image& src, int alpha, int x, int y, bool tiledFill) const
    {
        renderImageTransformed (iter, src, alpha, AffineTransform::translation ((float) x, (float) y),
                                Graphics::lowResamplingQuality, tiledFill);
    }

    template <typename IteratorType>
    void fillWithSolidColour (IteratorType& iter, PixelARGB colour, bool replaceContents) const
    {
        if (! isUsingCustomShader)
        {
            state->activeTextures.disableTextures (state->shaderQuadQueue);

            if (replaceContents)
                state->blendMode.disableBlend (state->shaderQuadQueue);
            else
                state->blendMode.setBlendMode (state->shaderQuadQueue, imageBlendMode);

            state->setShader (state->currentShader.programs->solidColourProgram);
        }

        state->shaderQuadQueue.add (iter, colour);
    }

    template <typename IteratorType>
    void fillWithGradient (IteratorType& iter, ColourGradient& gradient, const AffineTransform& trans, bool /*isIdentity*/) const
    {
        state->setShaderForGradientFill (gradient, trans, 0, nullptr);
        state->shaderQuadQueue.add (iter, fillType.colour.getPixelARGB());
    }

    void fillRectWithCustomShader (OpenGLRendering::ShaderPrograms::ShaderBase& shader, Rectangle<int> area)
    {
        state->setShader (shader);
        isUsingCustomShader = true;

        fillRect (area, true);

        isUsingCustomShader = false;
        state->currentShader.clearShader (state->shaderQuadQueue);
    }

    //==============================================================================
    Font font { FontOptions{} };
    GLState* state;
    bool isUsingCustomShader = false;

private:
    Image transparencyLayer;
    std::unique_ptr<Target> previousTarget;

    SavedState& operator= (const SavedState&);
};


//==============================================================================
struct ShaderContext final : public RenderingHelpers::StackBasedLowLevelGraphicsContext<SavedState>
{
    explicit ShaderContext (const Target& target)  : glState (target)
    {
        stack.initialise (new SavedState (&glState));
    }

    void fillRectWithCustomShader (ShaderPrograms::ShaderBase& shader, Rectangle<int> area)
    {
        static_cast<SavedState&> (*stack).fillRectWithCustomShader (shader, area);
    }

    std::unique_ptr<ImageType> getPreferredImageTypeForTemporaryImages() const override
    {
        return std::make_unique<OpenGLImageType>();
    }

    GLState glState;

    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ShaderContext)
};

struct NonShaderContext final : public LowLevelGraphicsSoftwareRenderer
{
    NonShaderContext (const Target& t, const Image& im)
        : LowLevelGraphicsSoftwareRenderer (im), target (t), image (im)
    {}

    ~NonShaderContext() override
    {
        JUCE_CHECK_OPENGL_ERROR
        auto previousFrameBufferTarget = OpenGLFrameBuffer::getCurrentFrameBufferTarget();

       #if ! JUCE_ANDROID
        target.context.extensions.glActiveTexture (GL_TEXTURE0);

        if (target.context.getProfile() == OpenGLProfile::compatibility)
            glEnable (GL_TEXTURE_2D);

        clearGLError();
       #endif

        ViewportRestorer viewportRestorer;

        OpenGLTexture texture;
        texture.loadImage (image);
        texture.bind();

        target.makeActive();
        target.context.copyTexture (target.bounds,
                                    Rectangle { texture.getWidth(), texture.getHeight() },
                                    target.bounds.getWidth(),
                                    target.bounds.getHeight(),
                                    false);
        glBindTexture (GL_TEXTURE_2D, 0);

       #if JUCE_WINDOWS
        if (target.context.extensions.glBindFramebuffer != nullptr)
       #endif
            target.context.extensions.glBindFramebuffer (GL_FRAMEBUFFER, previousFrameBufferTarget);

        JUCE_CHECK_OPENGL_ERROR
    }

    std::unique_ptr<ImageType> getPreferredImageTypeForTemporaryImages() const noexcept override
    {
        return std::make_unique<OpenGLImageType>();
    }

private:
    Target target;
    Image image;

    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (NonShaderContext)
};

static void clearOpenGLGlyphCacheCallback()
{
    RenderingHelpers::GlyphCache::getInstance().reset();
}

static std::unique_ptr<LowLevelGraphicsContext> createOpenGLContext (const Target& target)
{
    clearOpenGLGlyphCache = clearOpenGLGlyphCacheCallback;

    if (target.context.areShadersAvailable())
        return std::make_unique<ShaderContext> (target);

    Image tempImage (Image::ARGB, target.bounds.getWidth(), target.bounds.getHeight(), true, SoftwareImageType());
    return std::make_unique<NonShaderContext> (target, tempImage);
}

}

//==============================================================================
std::unique_ptr<LowLevelGraphicsContext> createOpenGLGraphicsContext (OpenGLContext& context, int width, int height)
{
    return createOpenGLGraphicsContext (context, context.getFrameBufferID(), width, height);
}

std::unique_ptr<LowLevelGraphicsContext> createOpenGLGraphicsContext (OpenGLContext& context, OpenGLFrameBuffer& target)
{
    return OpenGLRendering::createOpenGLContext (OpenGLRendering::Target (context, target, {}));
}

std::unique_ptr<LowLevelGraphicsContext> createOpenGLGraphicsContext (OpenGLContext& context, unsigned int frameBufferID, int width, int height)
{
    return OpenGLRendering::createOpenGLContext (OpenGLRendering::Target (context, frameBufferID, width, height));
}

//==============================================================================
struct CustomProgram final : public ReferenceCountedObject,
                             public OpenGLRendering::ShaderPrograms::ShaderBase
{
    CustomProgram (OpenGLRendering::ShaderContext& c, const String& fragmentShader)
        : ShaderBase (c.glState.target.context, fragmentShader.toRawUTF8())
    {
    }

    static ReferenceCountedObjectPtr<CustomProgram> get (const String& hashName)
    {
        if (auto* c = OpenGLContext::getCurrentContext())
            if (auto* o = c->getAssociatedObject (hashName.toRawUTF8()))
                return *static_cast<CustomProgram*> (o);

        return {};
    }

    static ReferenceCountedObjectPtr<CustomProgram> getOrCreate (LowLevelGraphicsContext& gc, const String& hashName,
                                                                 const String& code, String& errorMessage)
    {
        if (auto c = get (hashName))
            return c;

        if (auto* sc = dynamic_cast<OpenGLRendering::ShaderContext*> (&gc))
        {
            ReferenceCountedObjectPtr<CustomProgram> c (new CustomProgram (*sc, code));
            errorMessage = c->lastError;

            if (errorMessage.isEmpty())
            {
                if (auto context = OpenGLContext::getCurrentContext())
                {
                    context->setAssociatedObject (hashName.toRawUTF8(), c.get());
                    return c;
                }
            }
        }

        return nullptr;
    }

    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (CustomProgram)
};

OpenGLGraphicsContextCustomShader::OpenGLGraphicsContextCustomShader (const String& fragmentShaderCode)
    : code (String (JUCE_DECLARE_VARYING_COLOUR
                    JUCE_DECLARE_VARYING_PIXELPOS
                    "\n#define pixelAlpha frontColour.a\n") + fragmentShaderCode),
      hashName (String::toHexString (fragmentShaderCode.hashCode64()) + "_shader")
{
}

OpenGLGraphicsContextCustomShader::~OpenGLGraphicsContextCustomShader()
{
    if (OpenGLContext* context = OpenGLContext::getCurrentContext())
        context->setAssociatedObject (hashName.toRawUTF8(), nullptr);
}

OpenGLShaderProgram* OpenGLGraphicsContextCustomShader::getProgram (LowLevelGraphicsContext& gc) const
{
    String errorMessage;

    if (auto c = CustomProgram::getOrCreate (gc, hashName, code, errorMessage))
        return &(c->program);

    return {};
}

void OpenGLGraphicsContextCustomShader::fillRect (LowLevelGraphicsContext& gc, Rectangle<int> area) const
{
    String errorMessage;

    if (auto sc = dynamic_cast<OpenGLRendering::ShaderContext*> (&gc))
    {
        if (auto c = CustomProgram::getOrCreate (gc, hashName, code, errorMessage))
        {
            c->onShaderActivated = onShaderActivated;
            sc->fillRectWithCustomShader (*c, area);
        }
    }
}

Result OpenGLGraphicsContextCustomShader::checkCompilation (LowLevelGraphicsContext& gc)
{
    String errorMessage;

    if (CustomProgram::getOrCreate (gc, hashName, code, errorMessage) != nullptr)
        return Result::ok();

    return Result::fail (errorMessage);
}

template <>
void RenderingHelpers::SavedStateBase<juce::OpenGLRendering::SavedState>::dispatchFillAllWithGradient (typename BaseRegionType::Ptr shapeToFill)
{
    const auto& gradient = *fillType.gradient;

    if ((gradient.isRadial && detail::TwoPointConicalGradient::create (gradient).has_value())
        || gradient.spreadMethod != ColourGradient::SpreadMethod::pad)
    {
        const auto gradientImage = fillType.getSoftwareGradientImage (clip->getClipBounds());
        renderImage (gradientImage, {}, shapeToFill.get());
        return;
    }

    fillAllWithGradient (shapeToFill);
}

} // namespace juce
