mirror of
https://github.com/juce-framework/JUCE.git
synced 2026-01-10 23:44:24 +00:00
590 lines
18 KiB
C++
590 lines
18 KiB
C++
/*
|
|
==============================================================================
|
|
|
|
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-8-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
|
|
{
|
|
|
|
/*
|
|
Used on Android to detect when the GL context and associated resources (textures, framebuffers,
|
|
etc.) need to be destroyed/created due to the Surface changing state.
|
|
*/
|
|
class OpenGLContext::NativeContextListener
|
|
{
|
|
public:
|
|
virtual ~NativeContextListener() = default;
|
|
|
|
virtual void contextWillPause() = 0;
|
|
virtual void contextDidResume() = 0;
|
|
|
|
static void addListener (OpenGLContext& ctx, NativeContextListener& l);
|
|
static void removeListener (OpenGLContext& ctx, NativeContextListener& l);
|
|
};
|
|
|
|
class OpenGLFrameBuffer::Pimpl : private OpenGLContext::NativeContextListener
|
|
{
|
|
public:
|
|
struct SavedState
|
|
{
|
|
int width = 0, height = 0;
|
|
std::vector<PixelARGB> data;
|
|
|
|
static constexpr auto order = RowOrder::fromBottomUp;
|
|
};
|
|
|
|
~Pimpl() override
|
|
{
|
|
release();
|
|
}
|
|
|
|
bool isValid() const noexcept
|
|
{
|
|
return std::holds_alternative<TransientState> (state);
|
|
}
|
|
|
|
bool initialise (OpenGLContext& context, int width, int height)
|
|
{
|
|
jassert (context.isActive()); // The context must be active when creating a framebuffer!
|
|
|
|
release();
|
|
auto& transientState = state.emplace<TransientState> (width, height, false, false);
|
|
|
|
if (! transientState.createdOk())
|
|
release();
|
|
|
|
if (! isValid())
|
|
return false;
|
|
|
|
associatedContext = &context;
|
|
NativeContextListener::addListener (*associatedContext, *this);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool initialise (OpenGLContext& context, const Image& image)
|
|
{
|
|
if (! image.isARGB())
|
|
return initialise (context, image.convertedToFormat (Image::ARGB));
|
|
|
|
Image::BitmapData bitmap (image, Image::BitmapData::readOnly);
|
|
|
|
return initialise (context, bitmap.width, bitmap.height)
|
|
&& writePixels ((const PixelARGB*) bitmap.data, image.getBounds(), RowOrder::fromTopDown);
|
|
}
|
|
|
|
bool initialise (OpenGLFrameBuffer& other)
|
|
{
|
|
auto* p = std::get_if<TransientState> (&other.pimpl->state);
|
|
|
|
if (p == nullptr || other.pimpl->associatedContext == nullptr)
|
|
{
|
|
release();
|
|
return true;
|
|
}
|
|
|
|
const Rectangle<int> area (p->width, p->height);
|
|
|
|
if (! initialise (*other.pimpl->associatedContext, area.getWidth(), area.getHeight()))
|
|
return false;
|
|
|
|
jassert (associatedContext != nullptr);
|
|
|
|
auto* transientState = std::get_if<TransientState> (&state);
|
|
transientState->bind();
|
|
const ScopeGuard unbinder { [transientState] { transientState->unbind(); }};
|
|
|
|
#if ! JUCE_ANDROID
|
|
if (! associatedContext->isCoreProfile())
|
|
glEnable (GL_TEXTURE_2D);
|
|
|
|
clearGLError();
|
|
#endif
|
|
{
|
|
const ScopedTextureBinding scopedTextureBinding;
|
|
glBindTexture (GL_TEXTURE_2D, p->textureID);
|
|
associatedContext->copyTexture (area, area, area.getWidth(), area.getHeight(), false);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void release()
|
|
{
|
|
if (auto* prev = std::exchange (associatedContext, nullptr))
|
|
NativeContextListener::removeListener (*prev, *this);
|
|
|
|
state.emplace<std::monostate>();
|
|
}
|
|
|
|
void saveAndRelease()
|
|
{
|
|
if (auto* transientState = std::get_if<TransientState> (&state))
|
|
{
|
|
if (auto toSave = readPixels ({ transientState->width, transientState->height }))
|
|
state.emplace<SavedState> (std::move (*toSave));
|
|
}
|
|
}
|
|
|
|
bool reloadSavedCopy (OpenGLContext& context)
|
|
{
|
|
if (auto* savedState = std::get_if<SavedState> (&state))
|
|
{
|
|
auto local = std::move (*savedState);
|
|
|
|
if (restore (context, local))
|
|
return true;
|
|
|
|
state.emplace<SavedState> (std::move (local));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int getWidth() const noexcept
|
|
{
|
|
if (auto* transientState = std::get_if<TransientState> (&state))
|
|
return transientState->width;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int getHeight() const noexcept
|
|
{
|
|
if (auto* transientState = std::get_if<TransientState> (&state))
|
|
return transientState->height;
|
|
|
|
return 0;
|
|
}
|
|
|
|
GLuint getTextureID() const noexcept
|
|
{
|
|
if (auto* transientState = std::get_if<TransientState> (&state))
|
|
return transientState->textureID;
|
|
|
|
return 0;
|
|
}
|
|
|
|
GLuint getFrameBufferID() const noexcept
|
|
{
|
|
if (auto* transientState = std::get_if<TransientState> (&state))
|
|
return transientState->frameBufferID;
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool makeCurrentRenderingTarget()
|
|
{
|
|
return makeAndGetCurrentRenderingTarget() != nullptr;
|
|
}
|
|
|
|
void releaseAsRenderingTarget()
|
|
{
|
|
if (auto* transientState = std::get_if<TransientState> (&state))
|
|
transientState->unbind();
|
|
}
|
|
|
|
void clear (Colour colour)
|
|
{
|
|
auto* transientState = makeAndGetCurrentRenderingTarget();
|
|
|
|
if (transientState == nullptr)
|
|
return;
|
|
|
|
const ScopeGuard unbinder { [transientState] { transientState->unbind(); }};
|
|
OpenGLHelpers::clear (colour);
|
|
}
|
|
|
|
void makeCurrentAndClear()
|
|
{
|
|
auto* transientState = makeAndGetCurrentRenderingTarget();
|
|
|
|
if (transientState == nullptr)
|
|
return;
|
|
|
|
glClearColor (0, 0, 0, 0);
|
|
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
|
|
}
|
|
|
|
bool readPixels (PixelARGB* target, const Rectangle<int>& area, RowOrder order)
|
|
{
|
|
auto* transientState = makeAndGetCurrentRenderingTarget();
|
|
|
|
if (transientState == nullptr)
|
|
return false;
|
|
|
|
const ScopeGuard unbinder { [transientState] { transientState->unbind(); }};
|
|
|
|
glPixelStorei (GL_PACK_ALIGNMENT, 4);
|
|
glReadPixels (area.getX(), area.getY(), area.getWidth(), area.getHeight(),
|
|
JUCE_RGBA_FORMAT, GL_UNSIGNED_BYTE, target);
|
|
|
|
if (order == RowOrder::fromTopDown)
|
|
{
|
|
auto* end = target + area.getWidth() * area.getHeight();
|
|
|
|
for (auto y = 0; y < area.getHeight() / 2; ++y)
|
|
{
|
|
const auto offset = area.getWidth() * y;
|
|
auto* rowA = target + offset;
|
|
auto* rowB = end - offset - area.getWidth();
|
|
|
|
for (auto x = 0; x < area.getWidth(); ++x)
|
|
std::swap (rowA[x], rowB[x]);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool writePixels (const PixelARGB* data, const Rectangle<int>& area, RowOrder order)
|
|
{
|
|
if (associatedContext == nullptr)
|
|
return false;
|
|
|
|
const OpenGLTargetSaver ts;
|
|
auto* transientState = makeAndGetCurrentRenderingTarget();
|
|
|
|
if (transientState == nullptr)
|
|
return false;
|
|
|
|
glDisable (GL_DEPTH_TEST);
|
|
glDisable (GL_BLEND);
|
|
JUCE_CHECK_OPENGL_ERROR
|
|
|
|
OpenGLTexture tex;
|
|
tex.loadARGB (data, area.getWidth(), area.getHeight());
|
|
|
|
glViewport (0, 0, transientState->width, transientState->height);
|
|
associatedContext->copyTexture (area,
|
|
Rectangle<int> (area.getX(),
|
|
area.getY(),
|
|
tex.getWidth(),
|
|
tex.getHeight()),
|
|
transientState->width,
|
|
transientState->height,
|
|
order == RowOrder::fromTopDown,
|
|
false);
|
|
|
|
JUCE_CHECK_OPENGL_ERROR
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
/* Stores the currently-bound texture on construction, and re-binds it on destruction. */
|
|
struct ScopedTextureBinding
|
|
{
|
|
ScopedTextureBinding()
|
|
{
|
|
glGetIntegerv (GL_TEXTURE_BINDING_2D, &prev);
|
|
JUCE_CHECK_OPENGL_ERROR
|
|
}
|
|
|
|
~ScopedTextureBinding()
|
|
{
|
|
glBindTexture (GL_TEXTURE_2D, (GLuint) prev);
|
|
JUCE_CHECK_OPENGL_ERROR
|
|
}
|
|
|
|
GLint prev{};
|
|
};
|
|
|
|
class TransientState
|
|
{
|
|
public:
|
|
TransientState (const int w,
|
|
const int h,
|
|
const bool wantsDepthBuffer,
|
|
const bool wantsStencilBuffer)
|
|
: width (w),
|
|
height (h),
|
|
textureID (0),
|
|
frameBufferID (0),
|
|
depthOrStencilBuffer (0)
|
|
{
|
|
// Framebuffer objects can only be created when the current thread has an active OpenGL
|
|
// context. You'll need to create this object in one of the OpenGLContext's callbacks.
|
|
jassert (OpenGLHelpers::isContextActive());
|
|
|
|
#if JUCE_WINDOWS || JUCE_LINUX || JUCE_BSD
|
|
if (gl::glGenFramebuffers == nullptr)
|
|
return;
|
|
#endif
|
|
|
|
gl::glGenFramebuffers (1, &frameBufferID);
|
|
bind();
|
|
const ScopeGuard unbinder { [this] { unbind(); }};
|
|
|
|
{
|
|
const ScopedTextureBinding scopedTextureBinding;
|
|
|
|
glGenTextures (1, &textureID);
|
|
glBindTexture (GL_TEXTURE_2D, textureID);
|
|
JUCE_CHECK_OPENGL_ERROR
|
|
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
JUCE_CHECK_OPENGL_ERROR
|
|
|
|
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
|
JUCE_CHECK_OPENGL_ERROR
|
|
}
|
|
|
|
gl::glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureID, 0);
|
|
|
|
if (wantsDepthBuffer || wantsStencilBuffer)
|
|
{
|
|
gl::glGenRenderbuffers (1, &depthOrStencilBuffer);
|
|
gl::glBindRenderbuffer (GL_RENDERBUFFER, depthOrStencilBuffer);
|
|
jassert (gl::glIsRenderbuffer (depthOrStencilBuffer));
|
|
|
|
#if JUCE_OPENGL_ES
|
|
constexpr auto depthComponentConstant = (GLenum) GL_DEPTH_COMPONENT16;
|
|
#else
|
|
constexpr auto depthComponentConstant = (GLenum) GL_DEPTH_COMPONENT;
|
|
#endif
|
|
|
|
gl::glRenderbufferStorage (GL_RENDERBUFFER,
|
|
(wantsDepthBuffer && wantsStencilBuffer) ? (GLenum) GL_DEPTH24_STENCIL8
|
|
: depthComponentConstant,
|
|
width,
|
|
height);
|
|
|
|
GLint params = 0;
|
|
gl::glGetRenderbufferParameteriv (GL_RENDERBUFFER, GL_RENDERBUFFER_DEPTH_SIZE, ¶ms);
|
|
gl::glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthOrStencilBuffer);
|
|
|
|
if (wantsStencilBuffer)
|
|
gl::glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, depthOrStencilBuffer);
|
|
}
|
|
}
|
|
|
|
~TransientState()
|
|
{
|
|
if (! OpenGLHelpers::isContextActive())
|
|
return;
|
|
|
|
if (textureID != 0)
|
|
gl::glDeleteTextures (1, &textureID);
|
|
|
|
if (depthOrStencilBuffer != 0)
|
|
gl::glDeleteRenderbuffers (1, &depthOrStencilBuffer);
|
|
|
|
if (frameBufferID != 0)
|
|
gl::glDeleteFramebuffers (1, &frameBufferID);
|
|
|
|
JUCE_CHECK_OPENGL_ERROR
|
|
}
|
|
|
|
bool createdOk() const
|
|
{
|
|
return frameBufferID != 0 && textureID != 0;
|
|
}
|
|
|
|
void bind()
|
|
{
|
|
glGetIntegerv (GL_FRAMEBUFFER_BINDING, &prevFramebuffer);
|
|
gl::glBindFramebuffer (GL_FRAMEBUFFER, frameBufferID);
|
|
JUCE_CHECK_OPENGL_ERROR
|
|
}
|
|
|
|
void unbind()
|
|
{
|
|
gl::glBindFramebuffer (GL_FRAMEBUFFER, (GLuint) prevFramebuffer);
|
|
JUCE_CHECK_OPENGL_ERROR
|
|
}
|
|
|
|
const int width, height;
|
|
GLuint textureID, frameBufferID, depthOrStencilBuffer;
|
|
|
|
private:
|
|
GLint prevFramebuffer{};
|
|
|
|
JUCE_DECLARE_NON_COPYABLE (TransientState)
|
|
};
|
|
|
|
bool restore (OpenGLContext& context, const SavedState& savedState)
|
|
{
|
|
if (! initialise (context, savedState.width, savedState.height))
|
|
return false;
|
|
|
|
writePixels (savedState.data.data(),
|
|
Rectangle (savedState.width, savedState.height),
|
|
SavedState::order);
|
|
return true;
|
|
}
|
|
|
|
std::optional<SavedState> readPixels (const Rectangle<int>& area)
|
|
{
|
|
SavedState result { area.getWidth(),
|
|
area.getHeight(),
|
|
std::vector<PixelARGB> ((size_t) area.getWidth() * (size_t) area.getHeight()) };
|
|
|
|
if (! readPixels (result.data.data(), area, SavedState::order))
|
|
return {};
|
|
|
|
return result;
|
|
}
|
|
|
|
TransientState* makeAndGetCurrentRenderingTarget()
|
|
{
|
|
if (auto* transientState = std::get_if<TransientState> (&state))
|
|
{
|
|
transientState->bind();
|
|
return transientState;
|
|
}
|
|
|
|
// trying to use a framebuffer after saving it with saveAndRelease()! Be sure to call
|
|
// reloadSavedCopy() to put it back into GPU memory before using it
|
|
jassertfalse;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void contextWillPause() override
|
|
{
|
|
saveAndRelease();
|
|
}
|
|
|
|
void contextDidResume() override
|
|
{
|
|
if (associatedContext != nullptr)
|
|
reloadSavedCopy (*associatedContext);
|
|
}
|
|
|
|
OpenGLContext* associatedContext = nullptr;
|
|
std::variant<std::monostate, TransientState, SavedState> state;
|
|
};
|
|
|
|
//==============================================================================
|
|
OpenGLFrameBuffer::OpenGLFrameBuffer()
|
|
: pimpl (std::make_unique<Pimpl>())
|
|
{
|
|
}
|
|
|
|
OpenGLFrameBuffer::~OpenGLFrameBuffer() = default;
|
|
|
|
bool OpenGLFrameBuffer::initialise (OpenGLContext& context, int width, int height)
|
|
{
|
|
return pimpl->initialise (context, width, height);
|
|
}
|
|
|
|
bool OpenGLFrameBuffer::initialise (OpenGLContext& context, const Image& content)
|
|
{
|
|
return pimpl->initialise (context, content);
|
|
}
|
|
|
|
bool OpenGLFrameBuffer::initialise (OpenGLFrameBuffer& other)
|
|
{
|
|
return pimpl->initialise (other);
|
|
}
|
|
|
|
void OpenGLFrameBuffer::release()
|
|
{
|
|
pimpl->release();
|
|
}
|
|
|
|
void OpenGLFrameBuffer::saveAndRelease()
|
|
{
|
|
pimpl->saveAndRelease();
|
|
}
|
|
|
|
bool OpenGLFrameBuffer::reloadSavedCopy (OpenGLContext& context)
|
|
{
|
|
return pimpl->reloadSavedCopy (context);
|
|
}
|
|
|
|
bool OpenGLFrameBuffer::isValid() const noexcept
|
|
{
|
|
return pimpl->isValid();
|
|
}
|
|
|
|
int OpenGLFrameBuffer::getWidth() const noexcept
|
|
{
|
|
return pimpl->getWidth();
|
|
}
|
|
|
|
int OpenGLFrameBuffer::getHeight() const noexcept
|
|
{
|
|
return pimpl->getHeight();
|
|
}
|
|
|
|
GLuint OpenGLFrameBuffer::getTextureID() const noexcept
|
|
{
|
|
return pimpl->getTextureID();
|
|
}
|
|
|
|
bool OpenGLFrameBuffer::makeCurrentRenderingTarget()
|
|
{
|
|
return pimpl->makeCurrentRenderingTarget();
|
|
}
|
|
|
|
void OpenGLFrameBuffer::releaseAsRenderingTarget()
|
|
{
|
|
pimpl->releaseAsRenderingTarget();
|
|
}
|
|
|
|
GLuint OpenGLFrameBuffer::getFrameBufferID() const noexcept
|
|
{
|
|
return pimpl->getFrameBufferID();
|
|
}
|
|
|
|
void OpenGLFrameBuffer::clear (Colour colour)
|
|
{
|
|
pimpl->clear (colour);
|
|
}
|
|
|
|
void OpenGLFrameBuffer::makeCurrentAndClear()
|
|
{
|
|
pimpl->makeCurrentAndClear();
|
|
}
|
|
|
|
bool OpenGLFrameBuffer::readPixels (PixelARGB* targetData, const Rectangle<int>& sourceArea, RowOrder order)
|
|
{
|
|
return pimpl->readPixels (targetData, sourceArea, order);
|
|
}
|
|
|
|
bool OpenGLFrameBuffer::writePixels (const PixelARGB* srcData, const Rectangle<int>& targetArea, RowOrder order)
|
|
{
|
|
return pimpl->writePixels (srcData, targetArea, order);
|
|
}
|
|
|
|
GLuint OpenGLFrameBuffer::getCurrentFrameBufferTarget() noexcept
|
|
{
|
|
GLint fb = {};
|
|
glGetIntegerv (GL_FRAMEBUFFER_BINDING, &fb);
|
|
return (GLuint) fb;
|
|
}
|
|
|
|
} // namespace juce
|