mirror of
https://github.com/juce-framework/JUCE.git
synced 2026-01-10 23:44:24 +00:00
1273 lines
49 KiB
C++
1273 lines
49 KiB
C++
/*
|
|
==============================================================================
|
|
|
|
This file is part of the JUCE library - "Jules' Utility Class Extensions"
|
|
Copyright 2004-11 by Raw Material Software Ltd.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
JUCE can be redistributed and/or modified under the terms of the GNU General
|
|
Public License (Version 2), as published by the Free Software Foundation.
|
|
A copy of the license is included in the JUCE distribution, or can be found
|
|
online at www.gnu.org/licenses.
|
|
|
|
JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
|
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
To release a closed-source product which uses JUCE, commercial licenses are
|
|
available: visit www.rawmaterialsoftware.com/juce for more information.
|
|
|
|
==============================================================================
|
|
*/
|
|
|
|
BEGIN_JUCE_NAMESPACE
|
|
|
|
struct OpenGLTarget
|
|
{
|
|
OpenGLTarget (GLuint frameBufferID_, int width_, int height_) noexcept
|
|
: frameBuffer (nullptr), frameBufferID (frameBufferID_),
|
|
x (0), y (0), width (width_), height (height_)
|
|
{}
|
|
|
|
OpenGLTarget (OpenGLFrameBuffer& frameBuffer_, const Point<int>& origin) noexcept
|
|
: frameBuffer (&frameBuffer_), frameBufferID (0), x (origin.getX()), y (origin.getY()),
|
|
width (frameBuffer_.getWidth()), height (frameBuffer_.getHeight())
|
|
{}
|
|
|
|
OpenGLTarget (const OpenGLTarget& other) noexcept
|
|
: frameBuffer (other.frameBuffer), frameBufferID (other.frameBufferID),
|
|
x (other.x), y (other.y), width (other.width), height (other.height)
|
|
{}
|
|
|
|
void makeActiveFor2D() const
|
|
{
|
|
if (frameBuffer != nullptr)
|
|
frameBuffer->makeCurrentRenderingTarget();
|
|
else
|
|
OpenGLFrameBuffer::setCurrentFrameBufferTarget (frameBufferID);
|
|
|
|
applyFlippedMatrix (x, y, width, height);
|
|
glDisable (GL_DEPTH_TEST);
|
|
}
|
|
|
|
void scissor (Rectangle<int> r) const
|
|
{
|
|
r = r.translated (-x, -y);
|
|
OpenGLHelpers::enableScissorTest (r.withY (height - r.getBottom()));
|
|
}
|
|
|
|
static void applyFlippedMatrix (const int x, const int y, const int width, const int height)
|
|
{
|
|
glMatrixMode (GL_PROJECTION);
|
|
glLoadIdentity();
|
|
|
|
#if JUCE_OPENGL_ES
|
|
glOrthof ((GLfloat) x, (GLfloat) (x + width), (GLfloat) (y + height), (GLfloat) y, 0.0f, 1.0f);
|
|
#else
|
|
glOrtho (x, x + width, y + height, y, 0, 1);
|
|
#endif
|
|
|
|
glViewport (0, 0, width, height);
|
|
}
|
|
|
|
OpenGLFrameBuffer* frameBuffer;
|
|
GLuint frameBufferID;
|
|
int x, y, width, height;
|
|
};
|
|
|
|
//==============================================================================
|
|
namespace
|
|
{
|
|
enum { defaultOversamplingLevel = 4 };
|
|
|
|
void fillRectangleList (const RectangleList& list)
|
|
{
|
|
glEnableClientState (GL_VERTEX_ARRAY);
|
|
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
|
|
|
|
GLfloat vertices [8];
|
|
glVertexPointer (2, GL_FLOAT, 0, vertices);
|
|
|
|
for (RectangleList::Iterator i (list); i.next();)
|
|
{
|
|
vertices[0] = vertices[4] = (GLfloat) i.getRectangle()->getX();
|
|
vertices[1] = vertices[3] = (GLfloat) i.getRectangle()->getY();
|
|
vertices[2] = vertices[6] = (GLfloat) i.getRectangle()->getRight();
|
|
vertices[5] = vertices[7] = (GLfloat) i.getRectangle()->getBottom();
|
|
|
|
glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
|
|
}
|
|
}
|
|
|
|
inline void setColour (const float alpha) noexcept
|
|
{
|
|
glColor4f (alpha, alpha, alpha, alpha);
|
|
}
|
|
|
|
void clipFrameBuffers (const OpenGLTarget& dest, OpenGLFrameBuffer& source, const Point<int> sourceOrigin)
|
|
{
|
|
dest.makeActiveFor2D();
|
|
glEnable (GL_BLEND);
|
|
glBlendFunc (GL_ZERO, GL_SRC_ALPHA);
|
|
setColour (1.0f);
|
|
OpenGLHelpers::drawTextureQuad (source.getTextureID(), sourceOrigin.getX(), sourceOrigin.getY(),
|
|
source.getWidth(), source.getHeight());
|
|
}
|
|
|
|
void renderPath (const Path& path, const AffineTransform& transform, int oversamplingLevel)
|
|
{
|
|
glEnableClientState (GL_VERTEX_ARRAY);
|
|
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
|
|
glDisable (GL_TEXTURE_2D);
|
|
glEnable (GL_BLEND);
|
|
glBlendFunc (GL_ONE, GL_ONE);
|
|
|
|
TriangulatedPath (path, transform).draw (oversamplingLevel);
|
|
}
|
|
|
|
void setPremultipliedBlendingMode() noexcept
|
|
{
|
|
glEnable (GL_BLEND);
|
|
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
|
}
|
|
|
|
void setBlendMode (const bool replaceExistingContents) noexcept
|
|
{
|
|
if (replaceExistingContents)
|
|
glDisable (GL_BLEND);
|
|
else
|
|
setPremultipliedBlendingMode();
|
|
}
|
|
|
|
void fillRectWithTiledTexture (const OpenGLTarget& target, int textureWidth, int textureHeight,
|
|
const Rectangle<int>& clip, const AffineTransform& transform, float alpha)
|
|
{
|
|
glEnable (GL_TEXTURE_2D);
|
|
glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glEnableClientState (GL_VERTEX_ARRAY);
|
|
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
|
|
glDisableClientState (GL_COLOR_ARRAY);
|
|
glDisableClientState (GL_NORMAL_ARRAY);
|
|
glColor4f (1.0f, 1.0f, 1.0f, alpha);
|
|
|
|
static bool canDoNonPowerOfTwos = OpenGLHelpers::isExtensionSupported ("GL_ARB_texture_non_power_of_two");
|
|
|
|
if (canDoNonPowerOfTwos || (isPowerOfTwo (textureWidth) && isPowerOfTwo (textureHeight)))
|
|
{
|
|
glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
|
|
|
const GLfloat clipX = (GLfloat) clip.getX();
|
|
const GLfloat clipY = (GLfloat) clip.getY();
|
|
const GLfloat clipR = (GLfloat) clip.getRight();
|
|
const GLfloat clipB = (GLfloat) clip.getBottom();
|
|
|
|
const GLfloat vertices[] = { clipX, clipY, clipR, clipY, clipX, clipB, clipR, clipB };
|
|
GLfloat textureCoords[] = { clipX, clipY, clipR, clipY, clipX, clipB, clipR, clipB };
|
|
|
|
{
|
|
const AffineTransform t (transform.inverted().scaled (1.0f / textureWidth,
|
|
1.0f / textureHeight));
|
|
t.transformPoints (textureCoords[0], textureCoords[1], textureCoords[2], textureCoords[3]);
|
|
t.transformPoints (textureCoords[4], textureCoords[5], textureCoords[6], textureCoords[7]);
|
|
|
|
textureCoords[1] = 1.0f - textureCoords[1];
|
|
textureCoords[3] = 1.0f - textureCoords[3];
|
|
textureCoords[5] = 1.0f - textureCoords[5];
|
|
textureCoords[7] = 1.0f - textureCoords[7];
|
|
}
|
|
|
|
glVertexPointer (2, GL_FLOAT, 0, vertices);
|
|
glTexCoordPointer (2, GL_FLOAT, 0, textureCoords);
|
|
|
|
glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
|
|
}
|
|
else
|
|
{
|
|
// For hardware that can't handle non-power-of-two textures, this is a fallback algorithm
|
|
glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
target.scissor (clip);
|
|
glPushMatrix();
|
|
OpenGLHelpers::applyTransform (transform);
|
|
|
|
GLfloat vertices[8];
|
|
const GLfloat textureCoords[] = { 0, 0, 1.0f, 0, 0, 1.0f, 1.0f, 1.0f };
|
|
glVertexPointer (2, GL_FLOAT, 0, vertices);
|
|
glTexCoordPointer (2, GL_FLOAT, 0, textureCoords);
|
|
|
|
const Rectangle<int> targetArea (clip.toFloat().transformed (transform.inverted()).getSmallestIntegerContainer());
|
|
int x = targetArea.getX() - negativeAwareModulo (targetArea.getX(), textureWidth);
|
|
int y = targetArea.getY() - negativeAwareModulo (targetArea.getY(), textureHeight);
|
|
const int right = targetArea.getRight();
|
|
const int bottom = targetArea.getBottom();
|
|
|
|
while (y < bottom)
|
|
{
|
|
vertices[1] = vertices[3] = (GLfloat) y;
|
|
vertices[5] = vertices[7] = (GLfloat) (y + textureHeight);
|
|
|
|
for (int x1 = x; x1 < right; x1 += textureWidth)
|
|
{
|
|
vertices[0] = vertices[4] = (GLfloat) x1;
|
|
vertices[2] = vertices[6] = (GLfloat) (x1 + textureWidth);
|
|
glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
|
|
}
|
|
|
|
y += textureHeight;
|
|
}
|
|
|
|
glPopMatrix();
|
|
glDisable (GL_SCISSOR_TEST);
|
|
}
|
|
}
|
|
|
|
void fillWithLinearGradient (const Rectangle<int>& rect,
|
|
const ColourGradient& grad,
|
|
const AffineTransform& transform,
|
|
const int textureSize)
|
|
{
|
|
const Point<float> p1 (grad.point1.transformedBy (transform));
|
|
const Point<float> p2 (grad.point2.transformedBy (transform));
|
|
const Point<float> p3 (Point<float> (grad.point1.getX() - (grad.point2.getY() - grad.point1.getY()) / textureSize,
|
|
grad.point1.getY() + (grad.point2.getX() - grad.point1.getX()) / textureSize).transformedBy (transform));
|
|
|
|
const AffineTransform textureTransform (AffineTransform::fromTargetPoints (p1.getX(), p1.getY(), 0.0f, 0.0f,
|
|
p2.getX(), p2.getY(), 1.0f, 0.0f,
|
|
p3.getX(), p3.getY(), 0.0f, 1.0f));
|
|
|
|
const GLfloat l = (GLfloat) rect.getX();
|
|
const GLfloat r = (GLfloat) rect.getRight();
|
|
const GLfloat t = (GLfloat) rect.getY();
|
|
const GLfloat b = (GLfloat) rect.getBottom();
|
|
|
|
const GLfloat vertices[] = { l, t, r, t, l, b, r, b };
|
|
GLfloat textureCoords[] = { l, t, r, t, l, b, r, b };
|
|
|
|
textureTransform.transformPoints (textureCoords[0], textureCoords[1], textureCoords[2], textureCoords[3]);
|
|
textureTransform.transformPoints (textureCoords[4], textureCoords[5], textureCoords[6], textureCoords[7]);
|
|
|
|
setColour (1.0f);
|
|
OpenGLHelpers::drawTriangleStrip (vertices, textureCoords, 4);
|
|
}
|
|
|
|
void fillWithRadialGradient (const OpenGLTarget& target, const Rectangle<int>& rect,
|
|
const ColourGradient& grad, const AffineTransform& transform)
|
|
{
|
|
const Point<float> centre (grad.point1.transformedBy (transform));
|
|
|
|
const float screenRadius = centre.getDistanceFrom (rect.getCentre().toFloat())
|
|
+ Point<int> (rect.getWidth() / 2,
|
|
rect.getHeight() / 2).getDistanceFromOrigin()
|
|
+ 8.0f;
|
|
|
|
const AffineTransform inverse (transform.inverted());
|
|
const float sourceRadius = jmax (Point<float> (screenRadius, 0.0f).transformedBy (inverse).getDistanceFromOrigin(),
|
|
Point<float> (0.0f, screenRadius).transformedBy (inverse).getDistanceFromOrigin());
|
|
|
|
const int numDivisions = 90;
|
|
GLfloat vertices [4 + numDivisions * 2];
|
|
GLfloat textureCoords [4 + numDivisions * 2];
|
|
|
|
{
|
|
GLfloat* t = textureCoords;
|
|
*t++ = 0.0f;
|
|
*t++ = 0.0f;
|
|
|
|
const GLfloat texturePos = sourceRadius / grad.point1.getDistanceFrom (grad.point2);
|
|
|
|
for (int i = numDivisions + 1; --i >= 0;)
|
|
{
|
|
*t++ = texturePos;
|
|
*t++ = 0.0f;
|
|
}
|
|
}
|
|
|
|
{
|
|
GLfloat* v = vertices;
|
|
*v++ = centre.getX();
|
|
*v++ = centre.getY();
|
|
|
|
const Point<float> first (grad.point1.translated (0, -sourceRadius)
|
|
.transformedBy (transform));
|
|
*v++ = first.getX();
|
|
*v++ = first.getY();
|
|
|
|
for (int i = 1; i < numDivisions; ++i)
|
|
{
|
|
const float angle = i * (float_Pi * 2.0f / numDivisions);
|
|
const Point<float> p (grad.point1.translated (std::sin (angle) * sourceRadius,
|
|
std::cos (angle) * -sourceRadius)
|
|
.transformedBy (transform));
|
|
*v++ = p.getX();
|
|
*v++ = p.getY();
|
|
}
|
|
|
|
*v++ = first.getX();
|
|
*v++ = first.getY();
|
|
}
|
|
|
|
target.scissor (rect);
|
|
glEnable (GL_TEXTURE_2D);
|
|
glEnableClientState (GL_VERTEX_ARRAY);
|
|
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
|
|
glDisableClientState (GL_COLOR_ARRAY);
|
|
glDisableClientState (GL_NORMAL_ARRAY);
|
|
glVertexPointer (2, GL_FLOAT, 0, vertices);
|
|
glTexCoordPointer (2, GL_FLOAT, 0, textureCoords);
|
|
setColour (1.0f);
|
|
glDrawArrays (GL_TRIANGLE_FAN, 0, numDivisions + 2);
|
|
glDisable (GL_SCISSOR_TEST);
|
|
}
|
|
|
|
void fillRectWithColourGradient (const OpenGLTarget& target, const Rectangle<int>& rect,
|
|
const ColourGradient& gradient, const AffineTransform& transform)
|
|
{
|
|
if (gradient.point1 == gradient.point2)
|
|
{
|
|
OpenGLHelpers::fillRectWithColour (rect, gradient.getColourAtPosition (1.0));
|
|
}
|
|
else
|
|
{
|
|
const int textureSize = 256;
|
|
OpenGLTexture texture;
|
|
|
|
HeapBlock<PixelARGB> lookup (textureSize);
|
|
gradient.createLookupTable (lookup, textureSize);
|
|
texture.load (lookup, textureSize, 1);
|
|
texture.bind();
|
|
|
|
if (gradient.isRadial)
|
|
fillWithRadialGradient (target, rect, gradient, transform);
|
|
else
|
|
fillWithLinearGradient (rect, gradient, transform, textureSize);
|
|
}
|
|
}
|
|
|
|
void fillRectWithFillType (const OpenGLTarget& target, const Rectangle<int>& rect,
|
|
const FillType& fill, const bool replaceExistingContents)
|
|
{
|
|
if (fill.isGradient())
|
|
{
|
|
target.makeActiveFor2D();
|
|
setBlendMode (replaceExistingContents);
|
|
|
|
ColourGradient g2 (*(fill.gradient));
|
|
g2.multiplyOpacity (fill.getOpacity());
|
|
|
|
fillRectWithColourGradient (target, rect, g2, fill.transform);
|
|
}
|
|
else if (fill.isTiledImage())
|
|
{
|
|
OpenGLTextureFromImage t (fill.image);
|
|
|
|
target.makeActiveFor2D();
|
|
setBlendMode (replaceExistingContents);
|
|
|
|
glBindTexture (GL_TEXTURE_2D, t.textureID);
|
|
fillRectWithTiledTexture (target, t.width, t.height, rect,
|
|
fill.transform, fill.colour.getFloatAlpha());
|
|
glBindTexture (GL_TEXTURE_2D, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
//==============================================================================
|
|
class OpenGLRenderer::ScratchBufferManager
|
|
{
|
|
public:
|
|
ScratchBufferManager() {}
|
|
|
|
OpenGLFrameBuffer* get (int width, int height)
|
|
{
|
|
for (int i = 0; i < buffers.size(); ++i)
|
|
{
|
|
OpenGLFrameBuffer* b = buffers.getUnchecked(i);
|
|
|
|
if (width <= b->getWidth() && height <= b->getHeight())
|
|
return buffers.removeAndReturn (i);
|
|
}
|
|
|
|
OpenGLFrameBuffer* b = new OpenGLFrameBuffer();
|
|
b->initialise (width, height);
|
|
return b;
|
|
}
|
|
|
|
void release (OpenGLFrameBuffer* buffer)
|
|
{
|
|
buffers.add (buffer);
|
|
|
|
if (buffers.size() > 10)
|
|
buffers.remove (0);
|
|
}
|
|
|
|
private:
|
|
OwnedArray<OpenGLFrameBuffer> buffers;
|
|
|
|
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ScratchBufferManager);
|
|
};
|
|
|
|
class ClipRegion_Mask;
|
|
|
|
//==============================================================================
|
|
class ClipRegionBase : public SingleThreadedReferenceCountedObject
|
|
{
|
|
public:
|
|
ClipRegionBase (OpenGLRenderer::ScratchBufferManager& scratchBuffer_) noexcept : scratchBuffer (scratchBuffer_) {}
|
|
virtual ~ClipRegionBase() {}
|
|
|
|
typedef ReferenceCountedObjectPtr<ClipRegionBase> Ptr;
|
|
|
|
virtual Ptr clone() const = 0;
|
|
virtual Ptr applyClipTo (const Ptr& target) = 0;
|
|
virtual Ptr clipToRectangle (const Rectangle<int>&) = 0;
|
|
virtual Ptr clipToRectangleList (const RectangleList&) = 0;
|
|
virtual Ptr excludeClipRectangle (const Rectangle<int>&) = 0;
|
|
virtual Ptr clipToPath (const Path& p, const AffineTransform&) = 0;
|
|
virtual Ptr clipToEdgeTable (const EdgeTable&) = 0;
|
|
virtual Ptr clipToImageAlpha (const OpenGLTextureFromImage&, const AffineTransform&) = 0;
|
|
virtual Ptr clipToMask (ClipRegion_Mask*) = 0;
|
|
virtual const Rectangle<int>& getClipBounds() const = 0;
|
|
virtual void fillAll (const OpenGLTarget&, const FillType& fill, bool replaceContents) = 0;
|
|
virtual void fillRect (const OpenGLTarget&, const Rectangle<int>& area, const FillType& fill, bool replaceContents) = 0;
|
|
virtual void drawImage (const OpenGLTarget&, const OpenGLTextureFromImage&, float alpha, const Rectangle<int>& targetArea) = 0;
|
|
|
|
OpenGLRenderer::ScratchBufferManager& scratchBuffer;
|
|
|
|
private:
|
|
JUCE_DECLARE_NON_COPYABLE (ClipRegionBase);
|
|
};
|
|
|
|
//==============================================================================
|
|
class ClipRegion_Mask : public ClipRegionBase
|
|
{
|
|
public:
|
|
ClipRegion_Mask (const ClipRegion_Mask& other)
|
|
: ClipRegionBase (other.scratchBuffer),
|
|
clip (other.clip),
|
|
maskOrigin (other.clip.getPosition())
|
|
{
|
|
mask = scratchBuffer.get (clip.getWidth(), clip.getHeight());
|
|
|
|
OpenGLTarget m (*mask, maskOrigin);
|
|
m.makeActiveFor2D();
|
|
glDisable (GL_BLEND);
|
|
setColour (1.0f);
|
|
drawFrameBuffer (*(other.mask), other.maskOrigin);
|
|
}
|
|
|
|
explicit ClipRegion_Mask (const Rectangle<int>& r, OpenGLRenderer::ScratchBufferManager& scratchBuffer_)
|
|
: ClipRegionBase (scratchBuffer_),
|
|
clip (r),
|
|
maskOrigin (r.getPosition())
|
|
{
|
|
mask = scratchBuffer_.get (r.getWidth(), r.getHeight());
|
|
mask->clear (Colours::white);
|
|
}
|
|
|
|
explicit ClipRegion_Mask (const Rectangle<float>& r, OpenGLRenderer::ScratchBufferManager& scratchBuffer_)
|
|
: ClipRegionBase (scratchBuffer_),
|
|
clip (r.getSmallestIntegerContainer()),
|
|
maskOrigin (clip.getPosition())
|
|
{
|
|
initialiseClear();
|
|
|
|
glEnableClientState (GL_VERTEX_ARRAY);
|
|
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
|
|
|
|
RenderingHelpers::FloatRectangleRasterisingInfo fr (r);
|
|
FillFloatRectCallback callback;
|
|
fr.iterate (callback);
|
|
}
|
|
|
|
explicit ClipRegion_Mask (const EdgeTable& e, OpenGLRenderer::ScratchBufferManager& scratchBuffer_)
|
|
: ClipRegionBase (scratchBuffer_),
|
|
clip (e.getMaximumBounds()),
|
|
maskOrigin (clip.getPosition())
|
|
{
|
|
initialiseClear();
|
|
OpenGLHelpers::fillEdgeTable (e);
|
|
}
|
|
|
|
ClipRegion_Mask (OpenGLRenderer::ScratchBufferManager& scratchBuffer_, const Rectangle<int>& bounds,
|
|
const Path& p, const AffineTransform& transform, int oversamplingLevel)
|
|
: ClipRegionBase (scratchBuffer_),
|
|
clip (bounds), maskOrigin (clip.getPosition())
|
|
{
|
|
initialiseClear();
|
|
renderPath (p, transform, oversamplingLevel);
|
|
}
|
|
|
|
~ClipRegion_Mask()
|
|
{
|
|
scratchBuffer.release (mask);
|
|
}
|
|
|
|
static ClipRegion_Mask* createFromPath (OpenGLRenderer::ScratchBufferManager& scratchBuffer, Rectangle<int> bounds,
|
|
const Path& p, const AffineTransform& transform)
|
|
{
|
|
bounds = bounds.getIntersection (p.getBoundsTransformed (transform).getSmallestIntegerContainer());
|
|
|
|
return bounds.isEmpty() ? nullptr
|
|
: new ClipRegion_Mask (scratchBuffer, bounds, p, transform, (int) defaultOversamplingLevel);
|
|
}
|
|
|
|
Ptr clone() const { return new ClipRegion_Mask (*this); }
|
|
const Rectangle<int>& getClipBounds() const { return clip; }
|
|
Ptr applyClipTo (const Ptr& target) { return target->clipToMask (this); }
|
|
|
|
Ptr clipToRectangle (const Rectangle<int>& r)
|
|
{
|
|
clip = clip.getIntersection (r);
|
|
return clip.isEmpty() ? nullptr : this;
|
|
}
|
|
|
|
Ptr clipToRectangleList (const RectangleList& r)
|
|
{
|
|
clip = clip.getIntersection (r.getBounds());
|
|
if (clip.isEmpty())
|
|
return nullptr;
|
|
|
|
RectangleList excluded (clip);
|
|
|
|
if (excluded.subtract (r))
|
|
{
|
|
if (excluded.getNumRectangles() == 1)
|
|
return excludeClipRectangle (excluded.getRectangle (0));
|
|
|
|
makeMaskActive();
|
|
glDisable (GL_BLEND);
|
|
setColour (0);
|
|
fillRectangleList (excluded);
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
Ptr excludeClipRectangle (const Rectangle<int>& r)
|
|
{
|
|
if (r.contains (clip))
|
|
return nullptr;
|
|
|
|
makeMaskActive();
|
|
glDisable (GL_BLEND);
|
|
setColour (0);
|
|
OpenGLHelpers::fillRect (r);
|
|
return this;
|
|
}
|
|
|
|
Ptr clipToPath (const Path& p, const AffineTransform& t)
|
|
{
|
|
ClipRegion_Mask* tempMask = createFromPath (scratchBuffer, clip, p, t);
|
|
const Ptr tempMaskPtr (tempMask);
|
|
return tempMask == nullptr ? nullptr : clipToMask (tempMask);
|
|
}
|
|
|
|
Ptr clipToEdgeTable (const EdgeTable& et)
|
|
{
|
|
ClipRegion_Mask* const tempMask = new ClipRegion_Mask (et, scratchBuffer);
|
|
const Ptr tempMaskPtr (tempMask);
|
|
return clipToMask (tempMask);
|
|
}
|
|
|
|
Ptr clipToMask (ClipRegion_Mask* m)
|
|
{
|
|
jassert (m != nullptr && m != this);
|
|
clip = clip.getIntersection (m->clip);
|
|
|
|
if (clip.isEmpty())
|
|
return nullptr;
|
|
|
|
clipFrameBuffers (OpenGLTarget (*mask, maskOrigin), *(m->mask), m->maskOrigin);
|
|
return this;
|
|
}
|
|
|
|
Ptr clipToImageAlpha (const OpenGLTextureFromImage& image, const AffineTransform& transform)
|
|
{
|
|
makeMaskActive();
|
|
glEnable (GL_BLEND);
|
|
glBlendFunc (GL_ZERO, GL_SRC_ALPHA);
|
|
fillMaskWithSourceImage (image, transform);
|
|
return this;
|
|
}
|
|
|
|
void fillAll (const OpenGLTarget& target, const FillType& fill, bool replaceContents)
|
|
{
|
|
jassert (! replaceContents);
|
|
fillRectInternal (target, clip, fill, false);
|
|
}
|
|
|
|
void fillRect (const OpenGLTarget& target, const Rectangle<int>& area, const FillType& fill, bool replaceContents)
|
|
{
|
|
jassert (! replaceContents);
|
|
const Rectangle<int> r (clip.getIntersection (area));
|
|
|
|
if (! r.isEmpty())
|
|
fillRectInternal (target, r, fill, false);
|
|
}
|
|
|
|
void fillRectInternal (const OpenGLTarget& target, const Rectangle<int>& area, const FillType& fill, bool replaceContents)
|
|
{
|
|
if (fill.isColour())
|
|
{
|
|
target.makeActiveFor2D();
|
|
setBlendMode (replaceContents);
|
|
PixelARGB p (fill.colour.getARGB());
|
|
p.premultiply();
|
|
OpenGLHelpers::setColour (Colour (p.getARGB()));
|
|
target.scissor (area);
|
|
drawFrameBuffer (*mask, maskOrigin);
|
|
glDisable (GL_SCISSOR_TEST);
|
|
}
|
|
else
|
|
{
|
|
OpenGLFrameBuffer* patternBuffer = scratchBuffer.get (area.getWidth(), area.getHeight());
|
|
|
|
fillRectWithFillType (OpenGLTarget (*patternBuffer, area.getPosition()), area, fill, true);
|
|
clipAndDraw (target, OpenGLTarget (*patternBuffer, area.getPosition()), area);
|
|
|
|
scratchBuffer.release (patternBuffer);
|
|
}
|
|
}
|
|
|
|
void drawImage (const OpenGLTarget& target, const OpenGLTextureFromImage& source, float alpha, const Rectangle<int>& targetArea)
|
|
{
|
|
const Rectangle<int> bufferArea (targetArea.getIntersection (clip));
|
|
|
|
if (! bufferArea.isEmpty())
|
|
{
|
|
OpenGLFrameBuffer* buffer = scratchBuffer.get (bufferArea.getWidth(), bufferArea.getHeight());
|
|
|
|
OpenGLTarget bufferTarget (*buffer, bufferArea.getPosition());
|
|
bufferTarget.makeActiveFor2D();
|
|
glDisable (GL_BLEND);
|
|
OpenGLHelpers::fillRectWithTexture (targetArea, source.textureID, alpha);
|
|
|
|
clipAndDraw (target, bufferTarget, bufferArea);
|
|
|
|
scratchBuffer.release (buffer);
|
|
}
|
|
}
|
|
|
|
void drawImageSelfDestructively (const OpenGLTarget& target, const OpenGLTextureFromImage& source,
|
|
float alpha, const AffineTransform& transform)
|
|
{
|
|
makeMaskActive();
|
|
glEnable (GL_BLEND);
|
|
glBlendFunc (GL_DST_ALPHA, GL_ZERO);
|
|
fillMaskWithSourceImage (source, transform);
|
|
|
|
target.makeActiveFor2D();
|
|
setColour (alpha);
|
|
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
|
target.scissor (clip);
|
|
drawFrameBuffer (*mask, maskOrigin);
|
|
glDisable (GL_SCISSOR_TEST);
|
|
}
|
|
|
|
private:
|
|
OpenGLFrameBuffer* mask;
|
|
Rectangle<int> clip;
|
|
Point<int> maskOrigin;
|
|
|
|
void prepareFor2D() const
|
|
{
|
|
OpenGLTarget::applyFlippedMatrix (maskOrigin.getX(), maskOrigin.getY(), mask->getWidth(), mask->getHeight());
|
|
}
|
|
|
|
void makeMaskActive()
|
|
{
|
|
const bool b = mask->makeCurrentRenderingTarget();
|
|
(void) b; jassert (b);
|
|
prepareFor2D();
|
|
}
|
|
|
|
void initialiseClear()
|
|
{
|
|
jassert (! clip.isEmpty());
|
|
mask = scratchBuffer.get (clip.getWidth(), clip.getHeight());
|
|
mask->makeCurrentAndClear();
|
|
glDisable (GL_TEXTURE_2D);
|
|
glDisable (GL_BLEND);
|
|
prepareFor2D();
|
|
}
|
|
|
|
struct FillFloatRectCallback
|
|
{
|
|
void operator() (const int x, const int y, const int w, const int h, const int alpha) const
|
|
{
|
|
const GLfloat l = (GLfloat) x;
|
|
const GLfloat t = (GLfloat) y;
|
|
const GLfloat r = (GLfloat) (x + w);
|
|
const GLfloat b = (GLfloat) (y + h);
|
|
|
|
const GLfloat vertices[] = { l, t, r, t, l, b, r, b };
|
|
setColour (alpha / 255.0f);
|
|
glVertexPointer (2, GL_FLOAT, 0, vertices);
|
|
glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
|
|
}
|
|
};
|
|
|
|
void clipAndDraw (const OpenGLTarget& target, const OpenGLTarget& buffer, const Rectangle<int>& clip)
|
|
{
|
|
clipFrameBuffers (buffer, *mask, maskOrigin);
|
|
|
|
target.makeActiveFor2D();
|
|
glEnable (GL_BLEND);
|
|
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
|
setColour (1.0f);
|
|
target.scissor (clip);
|
|
|
|
drawFrameBuffer (*buffer.frameBuffer, Point<int> (buffer.x, buffer.y));
|
|
glDisable (GL_SCISSOR_TEST);
|
|
}
|
|
|
|
void drawFrameBuffer (const OpenGLFrameBuffer& buffer, const Point<int>& topLeft)
|
|
{
|
|
OpenGLHelpers::drawTextureQuad (buffer.getTextureID(), topLeft.getX(), topLeft.getY(),
|
|
buffer.getWidth(), buffer.getHeight());
|
|
}
|
|
|
|
void fillMaskWithSourceImage (const OpenGLTextureFromImage& image, const AffineTransform& transform) const
|
|
{
|
|
setColour (1.0f);
|
|
glBindTexture (GL_TEXTURE_2D, image.textureID);
|
|
glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
|
|
const GLfloat l = (GLfloat) maskOrigin.getX();
|
|
const GLfloat t = (GLfloat) maskOrigin.getY();
|
|
const GLfloat r = (GLfloat) (maskOrigin.getX() + mask->getWidth());
|
|
const GLfloat b = (GLfloat) (maskOrigin.getY() + mask->getHeight());
|
|
const GLfloat vertices[] = { l, t, r, t, l, b, r, b };
|
|
GLfloat textureCoords[] = { l, t, r, t, l, b, r, b };
|
|
|
|
const AffineTransform inv (transform.inverted().scaled (1.0f / image.width,
|
|
1.0f / image.height));
|
|
|
|
inv.transformPoints (textureCoords[0], textureCoords[1], textureCoords[2], textureCoords[3]);
|
|
inv.transformPoints (textureCoords[4], textureCoords[5], textureCoords[6], textureCoords[7]);
|
|
|
|
textureCoords[1] = 1.0f - textureCoords[1];
|
|
textureCoords[3] = 1.0f - textureCoords[3];
|
|
textureCoords[5] = 1.0f - textureCoords[5];
|
|
textureCoords[7] = 1.0f - textureCoords[7];
|
|
|
|
OpenGLHelpers::drawTriangleStrip (vertices, textureCoords, 4);
|
|
}
|
|
|
|
ClipRegion_Mask& operator= (const ClipRegion_Mask&);
|
|
};
|
|
|
|
|
|
//==============================================================================
|
|
class ClipRegion_Rectangle : public ClipRegionBase
|
|
{
|
|
public:
|
|
explicit ClipRegion_Rectangle (const Rectangle<int>& r, OpenGLRenderer::ScratchBufferManager& scratchBuffer_) noexcept
|
|
: ClipRegionBase (scratchBuffer_),
|
|
clip (r)
|
|
{}
|
|
|
|
Ptr clone() const { return new ClipRegion_Rectangle (clip, scratchBuffer); }
|
|
const Rectangle<int>& getClipBounds() const { return clip; }
|
|
Ptr applyClipTo (const Ptr& target) { return target->clipToRectangle (clip); }
|
|
|
|
Ptr clipToRectangle (const Rectangle<int>& r)
|
|
{
|
|
clip = clip.getIntersection (r);
|
|
return clip.isEmpty() ? nullptr : this;
|
|
}
|
|
|
|
Ptr clipToRectangleList (const RectangleList& r)
|
|
{
|
|
if (r.getNumRectangles() <= 1)
|
|
return clipToRectangle (r.getRectangle (0));
|
|
|
|
if (r.containsRectangle (clip))
|
|
return this;
|
|
|
|
return toMask()->clipToRectangleList (r);
|
|
}
|
|
|
|
Ptr excludeClipRectangle (const Rectangle<int>& r)
|
|
{
|
|
return r.contains (clip) ? nullptr
|
|
: toMask()->excludeClipRectangle (r);
|
|
}
|
|
|
|
Ptr clipToMask (ClipRegion_Mask* m) { return m->clipToRectangle (clip); }
|
|
Ptr clipToPath (const Path& p, const AffineTransform& transform) { return toMask()->clipToPath (p, transform); }
|
|
Ptr clipToEdgeTable (const EdgeTable& et) { return toMask()->clipToEdgeTable (et); }
|
|
Ptr clipToImageAlpha (const OpenGLTextureFromImage& image, const AffineTransform& transform) { return toMask()->clipToImageAlpha (image, transform); }
|
|
|
|
void fillAll (const OpenGLTarget& target, const FillType& fill, bool replaceContents)
|
|
{
|
|
fillRectInternal (target, clip, fill, replaceContents);
|
|
}
|
|
|
|
void fillRect (const OpenGLTarget& target, const Rectangle<int>& area, const FillType& fill, bool replaceContents)
|
|
{
|
|
const Rectangle<int> r (clip.getIntersection (area));
|
|
|
|
if (! r.isEmpty())
|
|
fillRectInternal (target, r, fill, replaceContents);
|
|
}
|
|
|
|
void drawImage (const OpenGLTarget& target, const OpenGLTextureFromImage& source, float alpha, const Rectangle<int>& targetArea)
|
|
{
|
|
target.makeActiveFor2D();
|
|
target.scissor (clip);
|
|
setPremultipliedBlendingMode();
|
|
OpenGLHelpers::fillRectWithTexture (targetArea, source.textureID, alpha);
|
|
glDisable (GL_SCISSOR_TEST);
|
|
}
|
|
|
|
private:
|
|
Rectangle<int> clip;
|
|
|
|
void fillRectInternal (const OpenGLTarget& target, const Rectangle<int>& area, const FillType& fill, bool replaceContents)
|
|
{
|
|
if (fill.isColour())
|
|
{
|
|
target.makeActiveFor2D();
|
|
setBlendMode (replaceContents);
|
|
glDisable (GL_TEXTURE_2D);
|
|
OpenGLHelpers::fillRectWithColour (area, fill.colour);
|
|
}
|
|
else
|
|
{
|
|
fillRectWithFillType (target, area, fill, replaceContents);
|
|
}
|
|
}
|
|
|
|
Ptr toMask() const
|
|
{
|
|
return new ClipRegion_Mask (clip, scratchBuffer);
|
|
}
|
|
|
|
ClipRegion_Rectangle& operator= (const ClipRegion_Rectangle&);
|
|
};
|
|
|
|
|
|
//==============================================================================
|
|
class OpenGLRenderer::SavedState
|
|
{
|
|
public:
|
|
SavedState (const OpenGLTarget& target_, ScratchBufferManager& scratchBuffer)
|
|
: clip (new ClipRegion_Rectangle (Rectangle<int> (target_.width, target_.height), scratchBuffer)),
|
|
transform (0, 0), interpolationQuality (Graphics::mediumResamplingQuality),
|
|
target (target_), transparencyLayerAlpha (1.0f)
|
|
{
|
|
}
|
|
|
|
SavedState (const SavedState& other)
|
|
: clip (other.clip), transform (other.transform), font (other.font),
|
|
fillType (other.fillType), interpolationQuality (other.interpolationQuality),
|
|
target (other.target), transparencyLayerAlpha (other.transparencyLayerAlpha),
|
|
transparencyLayer (other.transparencyLayer)
|
|
{
|
|
}
|
|
|
|
bool clipToRectangle (const Rectangle<int>& r)
|
|
{
|
|
if (clip != nullptr)
|
|
{
|
|
if (transform.isOnlyTranslated)
|
|
{
|
|
cloneClipIfMultiplyReferenced();
|
|
clip = clip->clipToRectangle (transform.translated (r));
|
|
}
|
|
else
|
|
{
|
|
Path p;
|
|
p.addRectangle (r);
|
|
clipToPath (p, AffineTransform::identity);
|
|
}
|
|
}
|
|
|
|
return clip != nullptr;
|
|
}
|
|
|
|
bool clipToRectangleList (const RectangleList& r)
|
|
{
|
|
if (clip != nullptr)
|
|
{
|
|
if (transform.isOnlyTranslated)
|
|
{
|
|
cloneClipIfMultiplyReferenced();
|
|
RectangleList offsetList (r);
|
|
offsetList.offsetAll (transform.xOffset, transform.yOffset);
|
|
clip = clip->clipToRectangleList (offsetList);
|
|
}
|
|
else
|
|
{
|
|
clipToPath (r.toPath(), AffineTransform::identity);
|
|
}
|
|
}
|
|
|
|
return clip != nullptr;
|
|
}
|
|
|
|
bool excludeClipRectangle (const Rectangle<int>& r)
|
|
{
|
|
if (clip != nullptr)
|
|
{
|
|
cloneClipIfMultiplyReferenced();
|
|
|
|
if (transform.isOnlyTranslated)
|
|
{
|
|
clip = clip->excludeClipRectangle (transform.translated (r));
|
|
}
|
|
else
|
|
{
|
|
Path p;
|
|
p.addRectangle (r.toFloat());
|
|
p.applyTransform (transform.complexTransform);
|
|
p.addRectangle (clip->getClipBounds().toFloat());
|
|
p.setUsingNonZeroWinding (false);
|
|
clip = clip->clipToPath (p, AffineTransform::identity);
|
|
}
|
|
}
|
|
|
|
return clip != nullptr;
|
|
}
|
|
|
|
void clipToPath (const Path& p, const AffineTransform& t)
|
|
{
|
|
if (clip != nullptr)
|
|
{
|
|
cloneClipIfMultiplyReferenced();
|
|
clip = clip->clipToPath (p, transform.getTransformWith (t));
|
|
}
|
|
}
|
|
|
|
void clipToImageAlpha (const Image& sourceImage, const AffineTransform& t)
|
|
{
|
|
if (clip != nullptr)
|
|
{
|
|
Path p;
|
|
p.addRectangle (sourceImage.getBounds());
|
|
clipToPath (p, t);
|
|
|
|
if (sourceImage.hasAlphaChannel() && clip != nullptr)
|
|
{
|
|
cloneClipIfMultiplyReferenced();
|
|
clip = clip->clipToImageAlpha (sourceImage, transform.getTransformWith (t));
|
|
}
|
|
}
|
|
}
|
|
|
|
bool clipRegionIntersects (const Rectangle<int>& r) const
|
|
{
|
|
return clip != nullptr
|
|
&& (transform.isOnlyTranslated ? clip->getClipBounds().intersects (transform.translated (r))
|
|
: getClipBounds().intersects (r));
|
|
}
|
|
|
|
Rectangle<int> getClipBounds() const
|
|
{
|
|
return clip != nullptr ? transform.deviceSpaceToUserSpace (clip->getClipBounds())
|
|
: Rectangle<int>();
|
|
}
|
|
|
|
SavedState* beginTransparencyLayer (float opacity)
|
|
{
|
|
SavedState* s = new SavedState (*this);
|
|
|
|
if (clip != nullptr)
|
|
{
|
|
const Rectangle<int>& clipBounds = clip->getClipBounds();
|
|
|
|
OpenGLFrameBufferImage* fbi = new OpenGLFrameBufferImage (clipBounds.getWidth(), clipBounds.getHeight());
|
|
fbi->frameBuffer.clear (Colours::transparentBlack);
|
|
|
|
s->transparencyLayer = Image (fbi);
|
|
s->target = OpenGLTarget (fbi->frameBuffer, clipBounds.getPosition());
|
|
s->transparencyLayerAlpha = opacity;
|
|
s->cloneClipIfMultiplyReferenced();
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
void endTransparencyLayer (SavedState& finishedLayerState)
|
|
{
|
|
if (clip != nullptr)
|
|
clip->drawImage (target, finishedLayerState.transparencyLayer,
|
|
finishedLayerState.transparencyLayerAlpha, clip->getClipBounds());
|
|
}
|
|
|
|
//==============================================================================
|
|
void fillRect (const Rectangle<int>& r, const bool replaceContents)
|
|
{
|
|
if (clip != nullptr)
|
|
{
|
|
if (transform.isOnlyTranslated)
|
|
{
|
|
clip->fillRect (target, r.translated (transform.xOffset, transform.yOffset),
|
|
getFillType(), replaceContents);
|
|
}
|
|
else
|
|
{
|
|
Path p;
|
|
p.addRectangle (r);
|
|
fillPath (p, AffineTransform::identity);
|
|
}
|
|
}
|
|
}
|
|
|
|
void fillRect (const Rectangle<float>& r)
|
|
{
|
|
if (clip != nullptr)
|
|
{
|
|
if (transform.isOnlyTranslated)
|
|
{
|
|
fillShape (new ClipRegion_Mask (r.translated ((float) transform.xOffset,
|
|
(float) transform.yOffset), clip->scratchBuffer), false);
|
|
}
|
|
else
|
|
{
|
|
Path p;
|
|
p.addRectangle (r);
|
|
fillPath (p, AffineTransform::identity);
|
|
}
|
|
}
|
|
}
|
|
|
|
void fillPath (const Path& path, const AffineTransform& t)
|
|
{
|
|
if (clip != nullptr)
|
|
{
|
|
ClipRegion_Mask* m = ClipRegion_Mask::createFromPath (clip->scratchBuffer, clip->getClipBounds(), path,
|
|
transform.getTransformWith (t));
|
|
|
|
if (m != nullptr)
|
|
fillShape (m, false);
|
|
}
|
|
}
|
|
|
|
void drawGlyph (int glyphNumber, const AffineTransform& t)
|
|
{
|
|
if (clip != nullptr)
|
|
{
|
|
if (transform.isOnlyTranslated && t.isOnlyTranslation())
|
|
{
|
|
RenderingHelpers::GlyphCache <CachedGlyphEdgeTable, SavedState>::getInstance()
|
|
.drawGlyph (*this, font, glyphNumber,
|
|
transform.xOffset + t.getTranslationX(),
|
|
transform.yOffset + t.getTranslationY());
|
|
}
|
|
else
|
|
{
|
|
const float fontHeight = font.getHeight();
|
|
|
|
const ScopedPointer<EdgeTable> et (font.getTypeface()->getEdgeTableForGlyph
|
|
(glyphNumber, transform.getTransformWith (AffineTransform::scale (fontHeight * font.getHorizontalScale(), fontHeight)
|
|
.followedBy (t))));
|
|
|
|
if (et != nullptr)
|
|
fillShape (new ClipRegion_Mask (*et, clip->scratchBuffer), false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void fillEdgeTable (const EdgeTable& et, float x, int y)
|
|
{
|
|
EdgeTable et2 (et);
|
|
et2.translate (x, y);
|
|
fillShape (new ClipRegion_Mask (et2, clip->scratchBuffer), false);
|
|
}
|
|
|
|
void drawLine (const Line <float>& line)
|
|
{
|
|
Path p;
|
|
p.addLineSegment (line, 1.0f);
|
|
fillPath (p, AffineTransform::identity);
|
|
}
|
|
|
|
void fillShape (ClipRegionBase::Ptr shapeToFill, const bool replaceContents)
|
|
{
|
|
jassert (clip != nullptr && shapeToFill != nullptr);
|
|
|
|
if (! fillType.isInvisible())
|
|
{
|
|
shapeToFill = clip->applyClipTo (shapeToFill);
|
|
|
|
if (shapeToFill != nullptr)
|
|
shapeToFill->fillAll (target, getFillType(), replaceContents);
|
|
}
|
|
}
|
|
|
|
//==============================================================================
|
|
void drawImage (const Image& image, const AffineTransform& trans)
|
|
{
|
|
if (clip == nullptr || fillType.colour.isTransparent())
|
|
return;
|
|
|
|
const AffineTransform t (transform.getTransformWith (trans));
|
|
const float alpha = fillType.colour.getFloatAlpha();
|
|
|
|
if (t.isOnlyTranslation())
|
|
{
|
|
int tx = (int) (t.getTranslationX() * 256.0f);
|
|
int ty = (int) (t.getTranslationY() * 256.0f);
|
|
|
|
if (((tx | ty) & 0xf8) == 0)
|
|
{
|
|
tx = ((tx + 128) >> 8);
|
|
ty = ((ty + 128) >> 8);
|
|
|
|
clip->drawImage (target, image, alpha, Rectangle<int> (tx, ty, image.getWidth(), image.getHeight()));
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (t.isSingularity())
|
|
return;
|
|
|
|
Path p;
|
|
p.addRectangle (image.getBounds());
|
|
ClipRegion_Mask* m = ClipRegion_Mask::createFromPath (clip->scratchBuffer, clip->getClipBounds(), p, t);
|
|
|
|
if (m != nullptr)
|
|
{
|
|
ClipRegionBase::Ptr c (clip->applyClipTo (m));
|
|
|
|
if (c != nullptr)
|
|
{
|
|
m = dynamic_cast<ClipRegion_Mask*> (c.getObject());
|
|
|
|
jassert (m != nullptr);
|
|
m->drawImageSelfDestructively (target, image, alpha, t);
|
|
}
|
|
}
|
|
}
|
|
|
|
//==============================================================================
|
|
ClipRegionBase::Ptr clip;
|
|
RenderingHelpers::TranslationOrTransform transform;
|
|
Font font;
|
|
FillType fillType;
|
|
Graphics::ResamplingQuality interpolationQuality;
|
|
|
|
private:
|
|
OpenGLTarget target;
|
|
float transparencyLayerAlpha;
|
|
Image transparencyLayer;
|
|
|
|
void cloneClipIfMultiplyReferenced()
|
|
{
|
|
if (clip->getReferenceCount() > 1)
|
|
clip = clip->clone();
|
|
}
|
|
|
|
FillType getFillType() const
|
|
{
|
|
return fillType.transformed (transform.getTransform());
|
|
}
|
|
|
|
class CachedGlyphEdgeTable
|
|
{
|
|
public:
|
|
CachedGlyphEdgeTable() : glyph (0), lastAccessCount (0) {}
|
|
|
|
void draw (OpenGLRenderer::SavedState& state, float x, const float y) const
|
|
{
|
|
if (snapToIntegerCoordinate)
|
|
x = std::floor (x + 0.5f);
|
|
|
|
if (edgeTable != nullptr)
|
|
state.fillEdgeTable (*edgeTable, x, roundToInt (y));
|
|
}
|
|
|
|
void generate (const Font& newFont, const int glyphNumber)
|
|
{
|
|
font = newFont;
|
|
snapToIntegerCoordinate = newFont.getTypeface()->isHinted();
|
|
glyph = glyphNumber;
|
|
|
|
const float fontHeight = font.getHeight();
|
|
edgeTable = font.getTypeface()->getEdgeTableForGlyph (glyphNumber,
|
|
AffineTransform::scale (fontHeight * font.getHorizontalScale(), fontHeight)
|
|
#if JUCE_MAC || JUCE_IOS
|
|
.translated (0.0f, -0.5f)
|
|
#endif
|
|
);
|
|
}
|
|
|
|
Font font;
|
|
int glyph, lastAccessCount;
|
|
bool snapToIntegerCoordinate;
|
|
|
|
private:
|
|
ScopedPointer <EdgeTable> edgeTable;
|
|
|
|
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (CachedGlyphEdgeTable);
|
|
};
|
|
|
|
SavedState& operator= (const SavedState&);
|
|
};
|
|
|
|
//==============================================================================
|
|
OpenGLRenderer::OpenGLRenderer (OpenGLComponent& target)
|
|
: scratchBufferManager (new ScratchBufferManager()),
|
|
stack (new SavedState (OpenGLTarget (target.getFrameBufferID(), target.getWidth(), target.getHeight()), *scratchBufferManager))
|
|
{
|
|
target.makeCurrentRenderingTarget();
|
|
}
|
|
|
|
OpenGLRenderer::OpenGLRenderer (OpenGLFrameBuffer& target)
|
|
: scratchBufferManager (new ScratchBufferManager()),
|
|
stack (new SavedState (OpenGLTarget (target, Point<int>()), *scratchBufferManager))
|
|
{
|
|
// This object can only be created and used when the current thread has an active OpenGL context.
|
|
jassert (OpenGLHelpers::isContextActive());
|
|
}
|
|
|
|
OpenGLRenderer::OpenGLRenderer (unsigned int frameBufferID, int width, int height)
|
|
: scratchBufferManager (new ScratchBufferManager()),
|
|
stack (new SavedState (OpenGLTarget (frameBufferID, width, height), *scratchBufferManager))
|
|
{
|
|
// This object can only be created and used when the current thread has an active OpenGL context.
|
|
jassert (OpenGLHelpers::isContextActive());
|
|
}
|
|
|
|
OpenGLRenderer::~OpenGLRenderer() {}
|
|
|
|
bool OpenGLRenderer::isVectorDevice() const { return false; }
|
|
void OpenGLRenderer::setOrigin (int x, int y) { stack->transform.setOrigin (x, y); }
|
|
void OpenGLRenderer::addTransform (const AffineTransform& t) { stack->transform.addTransform (t); }
|
|
float OpenGLRenderer::getScaleFactor() { return stack->transform.getScaleFactor(); }
|
|
Rectangle<int> OpenGLRenderer::getClipBounds() const { return stack->getClipBounds(); }
|
|
bool OpenGLRenderer::isClipEmpty() const { return stack->clip == nullptr; }
|
|
bool OpenGLRenderer::clipRegionIntersects (const Rectangle<int>& r) { return stack->clipRegionIntersects (r); }
|
|
bool OpenGLRenderer::clipToRectangle (const Rectangle<int>& r) { return stack->clipToRectangle (r); }
|
|
bool OpenGLRenderer::clipToRectangleList (const RectangleList& r) { return stack->clipToRectangleList (r); }
|
|
void OpenGLRenderer::excludeClipRectangle (const Rectangle<int>& r) { stack->excludeClipRectangle (r); }
|
|
void OpenGLRenderer::clipToPath (const Path& path, const AffineTransform& t) { stack->clipToPath (path, t); }
|
|
void OpenGLRenderer::clipToImageAlpha (const Image& im, const AffineTransform& t) { stack->clipToImageAlpha (im, t); }
|
|
void OpenGLRenderer::saveState() { stack.save(); }
|
|
void OpenGLRenderer::restoreState() { stack.restore(); }
|
|
void OpenGLRenderer::beginTransparencyLayer (float opacity) { stack.beginTransparencyLayer (opacity); }
|
|
void OpenGLRenderer::endTransparencyLayer() { stack.endTransparencyLayer(); }
|
|
void OpenGLRenderer::setFill (const FillType& fillType) { stack->fillType = fillType; }
|
|
void OpenGLRenderer::setOpacity (float newOpacity) { stack->fillType.setOpacity (newOpacity); }
|
|
void OpenGLRenderer::setInterpolationQuality (Graphics::ResamplingQuality quality) { stack->interpolationQuality = quality; }
|
|
void OpenGLRenderer::fillRect (const Rectangle<int>& r, bool replace) { stack->fillRect (r, replace); }
|
|
void OpenGLRenderer::fillPath (const Path& path, const AffineTransform& t) { stack->fillPath (path, t); }
|
|
void OpenGLRenderer::drawImage (const Image& im, const AffineTransform& t) { stack->drawImage (im, t); }
|
|
void OpenGLRenderer::drawVerticalLine (int x, float top, float bottom) { if (top < bottom) stack->fillRect (Rectangle<float> ((float) x, top, 1.0f, bottom - top)); }
|
|
void OpenGLRenderer::drawHorizontalLine (int y, float left, float right) { if (left < right) stack->fillRect (Rectangle<float> (left, (float) y, right - left, 1.0f)); }
|
|
void OpenGLRenderer::drawGlyph (int glyphNumber, const AffineTransform& t) { stack->drawGlyph (glyphNumber, t); }
|
|
void OpenGLRenderer::drawLine (const Line <float>& line) { stack->drawLine (line); }
|
|
void OpenGLRenderer::setFont (const Font& newFont) { stack->font = newFont; }
|
|
Font OpenGLRenderer::getFont() { return stack->font; }
|
|
|
|
END_JUCE_NAMESPACE
|