git subrepo clone --branch=sono6good https://github.com/essej/JUCE.git deps/juce
subrepo: subdir: "deps/juce" merged: "b13f9084e" upstream: origin: "https://github.com/essej/JUCE.git" branch: "sono6good" commit: "b13f9084e" git-subrepo: version: "0.4.3" origin: "https://github.com/ingydotnet/git-subrepo.git" commit: "2f68596"
This commit is contained in:
essej
374
deps/juce/modules/juce_opengl/opengl/juce_OpenGLContext.h
vendored
Normal file
374
deps/juce/modules/juce_opengl/opengl/juce_OpenGLContext.h
vendored
Normal file
@ -0,0 +1,374 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2020 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
|
||||
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
|
||||
|
||||
End User License Agreement: www.juce.com/juce-6-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
class OpenGLTexture;
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Creates an OpenGL context, which can be attached to a component.
|
||||
|
||||
To render some OpenGL, you should create an instance of an OpenGLContext,
|
||||
and call attachTo() to make it use a component as its render target.
|
||||
|
||||
To provide threaded rendering, you can supply an OpenGLRenderer object that
|
||||
will be used to render each frame.
|
||||
|
||||
Before your target component or OpenGLRenderer is deleted, you MUST call
|
||||
detach() or delete the OpenGLContext to allow the background thread to
|
||||
stop and the native resources to be freed safely.
|
||||
|
||||
@see OpenGLRenderer
|
||||
|
||||
@tags{OpenGL}
|
||||
*/
|
||||
class JUCE_API OpenGLContext
|
||||
{
|
||||
public:
|
||||
OpenGLContext();
|
||||
|
||||
/** Destructor. */
|
||||
~OpenGLContext();
|
||||
|
||||
//==============================================================================
|
||||
/** Gives the context an OpenGLRenderer to use to do the drawing.
|
||||
The object that you give it will not be owned by the context, so it's the caller's
|
||||
responsibility to manage its lifetime and make sure that it doesn't get deleted
|
||||
while the context may be using it. To stop the context using a renderer, just call
|
||||
this method with a null pointer.
|
||||
Note: This must be called BEFORE attaching your context to a target component!
|
||||
*/
|
||||
void setRenderer (OpenGLRenderer*) noexcept;
|
||||
|
||||
/** Attaches the context to a target component.
|
||||
|
||||
If the component is not fully visible, this call will wait until the component
|
||||
is shown before actually creating a native context for it.
|
||||
|
||||
When a native context is created, a thread is started, and will be used to call
|
||||
the OpenGLRenderer methods. The context will be floated above the target component,
|
||||
and when the target moves, it will track it. If the component is hidden/shown, the
|
||||
context may be deleted and re-created.
|
||||
*/
|
||||
void attachTo (Component&);
|
||||
|
||||
/** Detaches the context from its target component and deletes any native resources.
|
||||
If the context has not been attached, this will do nothing. Otherwise, it will block
|
||||
until the context and its thread have been cleaned up.
|
||||
*/
|
||||
void detach();
|
||||
|
||||
/** Returns true if the context is attached to a component and is on-screen.
|
||||
Note that if you call attachTo() for a non-visible component, this method will
|
||||
return false until the component is made visible.
|
||||
*/
|
||||
bool isAttached() const noexcept;
|
||||
|
||||
/** Returns the component to which this context is currently attached, or nullptr. */
|
||||
Component* getTargetComponent() const noexcept;
|
||||
|
||||
/** If the given component has an OpenGLContext attached, then this will return it. */
|
||||
static OpenGLContext* getContextAttachedTo (Component& component) noexcept;
|
||||
|
||||
//==============================================================================
|
||||
/** Sets the pixel format which you'd like to use for the target GL surface.
|
||||
Note: This must be called BEFORE attaching your context to a target component!
|
||||
*/
|
||||
void setPixelFormat (const OpenGLPixelFormat& preferredPixelFormat) noexcept;
|
||||
|
||||
/** Texture magnification filters, used by setTextureMagnificationFilter(). */
|
||||
enum TextureMagnificationFilter
|
||||
{
|
||||
nearest,
|
||||
linear
|
||||
};
|
||||
|
||||
/** Sets the texture magnification filter. By default the texture magnification
|
||||
filter is linear. However, for faster rendering you may want to use the
|
||||
'nearest' magnification filter. This option will not affect any textures
|
||||
created before this function was called. */
|
||||
void setTextureMagnificationFilter (TextureMagnificationFilter magFilterMode) noexcept;
|
||||
|
||||
//==============================================================================
|
||||
/** Provides a context with which you'd like this context's resources to be shared.
|
||||
The object passed-in here is a platform-dependent native context object, and
|
||||
must not be deleted while this context may still be using it! To turn off sharing,
|
||||
you can call this method with a null pointer.
|
||||
Note: This must be called BEFORE attaching your context to a target component!
|
||||
*/
|
||||
void setNativeSharedContext (void* nativeContextToShareWith) noexcept;
|
||||
|
||||
/** Enables multisampling on platforms where this is implemented.
|
||||
If enabling this, you must call this method before attachTo().
|
||||
*/
|
||||
void setMultisamplingEnabled (bool) noexcept;
|
||||
|
||||
/** Returns true if shaders can be used in this context. */
|
||||
bool areShadersAvailable() const;
|
||||
|
||||
/** HACK option when enabled prevents issues on some mobile opengl drivers */
|
||||
void setMobileBufferBugMitigation(bool flag);
|
||||
bool getMobileBufferBugMitigation() const;
|
||||
|
||||
/** Returns true if non-power-of-two textures are supported in this context. */
|
||||
bool isTextureNpotSupported() const;
|
||||
|
||||
/** OpenGL versions, used by setOpenGLVersionRequired(). */
|
||||
enum OpenGLVersion
|
||||
{
|
||||
defaultGLVersion = 0,
|
||||
openGL3_2
|
||||
};
|
||||
|
||||
/** Sets a preference for the version of GL that this context should use, if possible.
|
||||
Some platforms may ignore this value.
|
||||
*/
|
||||
void setOpenGLVersionRequired (OpenGLVersion) noexcept;
|
||||
|
||||
/** Enables or disables the use of the GL context to perform 2D rendering
|
||||
of the component to which it is attached.
|
||||
If this is false, then only your OpenGLRenderer will be used to perform
|
||||
any rendering. If true, then each time your target's paint() method needs
|
||||
to be called, an OpenGLGraphicsContext will be used to render it, (after
|
||||
calling your OpenGLRenderer if there is one).
|
||||
|
||||
By default this is set to true. If you're not using any paint() method functionality
|
||||
and are doing all your rendering in an OpenGLRenderer, you should disable it
|
||||
to improve performance.
|
||||
|
||||
Note: This must be called BEFORE attaching your context to a target component!
|
||||
*/
|
||||
void setComponentPaintingEnabled (bool shouldPaintComponent) noexcept;
|
||||
|
||||
/** Enables or disables continuous repainting.
|
||||
If set to true, the context will run a loop, re-rendering itself without waiting
|
||||
for triggerRepaint() to be called, at a frequency determined by the swap interval
|
||||
(see setSwapInterval). If false, then after each render callback, it will wait for
|
||||
another call to triggerRepaint() before rendering again.
|
||||
This is disabled by default.
|
||||
@see setSwapInterval
|
||||
*/
|
||||
void setContinuousRepainting (bool shouldContinuouslyRepaint) noexcept;
|
||||
|
||||
/** Asynchronously causes a repaint to be made. */
|
||||
void triggerRepaint();
|
||||
|
||||
//==============================================================================
|
||||
/** This retrieves an object that was previously stored with setAssociatedObject().
|
||||
If no object is found with the given name, this will return nullptr.
|
||||
This method must only be called from within the GL rendering methods.
|
||||
@see setAssociatedObject
|
||||
*/
|
||||
ReferenceCountedObject* getAssociatedObject (const char* name) const;
|
||||
|
||||
/** Attaches a named object to the context, which will be deleted when the context is
|
||||
destroyed.
|
||||
|
||||
This allows you to store an object which will be released before the context is
|
||||
deleted. The main purpose is for caching GL objects such as shader programs, which
|
||||
will become invalid when the context is deleted.
|
||||
|
||||
This method must only be called from within the GL rendering methods.
|
||||
*/
|
||||
void setAssociatedObject (const char* name, ReferenceCountedObject* newObject);
|
||||
|
||||
//==============================================================================
|
||||
/** Makes this context the currently active one.
|
||||
You should never need to call this in normal use - the context will already be
|
||||
active when OpenGLRenderer::renderOpenGL() is invoked.
|
||||
*/
|
||||
bool makeActive() const noexcept;
|
||||
|
||||
/** Returns true if this context is currently active for the calling thread. */
|
||||
bool isActive() const noexcept;
|
||||
|
||||
/** If any context is active on the current thread, this deactivates it.
|
||||
Note that on some platforms, like Android, this isn't possible.
|
||||
*/
|
||||
static void deactivateCurrentContext();
|
||||
|
||||
/** Returns the context that's currently in active use by the calling thread, or
|
||||
nullptr if no context is active.
|
||||
*/
|
||||
static OpenGLContext* getCurrentContext();
|
||||
|
||||
//==============================================================================
|
||||
/** Swaps the buffers (if the context can do this).
|
||||
There's normally no need to call this directly - the buffers will be swapped
|
||||
automatically after your OpenGLRenderer::renderOpenGL() method has been called.
|
||||
*/
|
||||
void swapBuffers();
|
||||
|
||||
/** Sets whether the context checks the vertical sync before swapping.
|
||||
|
||||
The value is the number of frames to allow between buffer-swapping. This is
|
||||
fairly system-dependent, but 0 turns off syncing, 1 makes it swap on frame-boundaries,
|
||||
and greater numbers indicate that it should swap less often.
|
||||
|
||||
By default, this will be set to 1.
|
||||
|
||||
Returns true if it sets the value successfully - some platforms won't support
|
||||
this setting.
|
||||
|
||||
@see setContinuousRepainting
|
||||
*/
|
||||
bool setSwapInterval (int numFramesPerSwap);
|
||||
|
||||
/** Returns the current swap-sync interval.
|
||||
See setSwapInterval() for info about the value returned.
|
||||
*/
|
||||
int getSwapInterval() const;
|
||||
|
||||
//==============================================================================
|
||||
/** Execute a lambda, function or functor on the OpenGL thread with an active
|
||||
context.
|
||||
|
||||
This method will attempt to execute functor on the OpenGL thread. If
|
||||
blockUntilFinished is true then the method will block until the functor
|
||||
has finished executing.
|
||||
|
||||
This function can only be called if the context is attached to a component.
|
||||
Otherwise, this function will assert.
|
||||
|
||||
This function is useful when you need to execute house-keeping tasks such
|
||||
as allocating, deallocating textures or framebuffers. As such, the functor
|
||||
will execute without locking the message thread. Therefore, it is not
|
||||
intended for any drawing commands or GUI code. Any GUI code should be
|
||||
executed in the OpenGLRenderer::renderOpenGL callback instead.
|
||||
*/
|
||||
template <typename T>
|
||||
void executeOnGLThread (T&& functor, bool blockUntilFinished);
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the scale factor used by the display that is being rendered.
|
||||
|
||||
The scale is that of the display - see Displays::Display::scale
|
||||
|
||||
Note that this should only be called during an OpenGLRenderer::renderOpenGL()
|
||||
callback - at other times the value it returns is undefined.
|
||||
*/
|
||||
double getRenderingScale() const noexcept { return currentRenderScale; }
|
||||
|
||||
//==============================================================================
|
||||
/** If this context is backed by a frame buffer, this returns its ID number,
|
||||
or 0 if the context does not use a framebuffer.
|
||||
*/
|
||||
unsigned int getFrameBufferID() const noexcept;
|
||||
|
||||
/** Returns an OS-dependent handle to some kind of underlying OS-provided GL context.
|
||||
|
||||
The exact type of the value returned will depend on the OS and may change
|
||||
if the implementation changes. If you want to use this, digging around in the
|
||||
native code is probably the best way to find out what it is.
|
||||
*/
|
||||
void* getRawContext() const noexcept;
|
||||
|
||||
/** This structure holds a set of dynamically loaded GL functions for use on this context. */
|
||||
OpenGLExtensionFunctions extensions;
|
||||
|
||||
//==============================================================================
|
||||
/** Draws the currently selected texture into this context at its original size.
|
||||
|
||||
@param targetClipArea the target area to draw into (in top-left origin coords)
|
||||
@param anchorPosAndTextureSize the position of this rectangle is the texture's top-left
|
||||
anchor position in the target space, and the size must be
|
||||
the total size of the texture.
|
||||
@param contextWidth the width of the context or framebuffer that is being drawn into,
|
||||
used for scaling of the coordinates.
|
||||
@param contextHeight the height of the context or framebuffer that is being drawn into,
|
||||
used for vertical flipping of the y coordinates.
|
||||
@param textureOriginIsBottomLeft if true, the texture's origin is treated as being at
|
||||
(0, 0). If false, it is assumed to be (0, 1)
|
||||
*/
|
||||
void copyTexture (const Rectangle<int>& targetClipArea,
|
||||
const Rectangle<int>& anchorPosAndTextureSize,
|
||||
int contextWidth, int contextHeight,
|
||||
bool textureOriginIsBottomLeft);
|
||||
|
||||
|
||||
/** Changes the amount of GPU memory that the internal cache for Images is allowed to use. */
|
||||
void setImageCacheSize (size_t cacheSizeBytes) noexcept;
|
||||
|
||||
/** Returns the amount of GPU memory that the internal cache for Images is allowed to use. */
|
||||
size_t getImageCacheSize() const noexcept;
|
||||
|
||||
//==============================================================================
|
||||
#ifndef DOXYGEN
|
||||
class NativeContext;
|
||||
#endif
|
||||
|
||||
private:
|
||||
friend class OpenGLTexture;
|
||||
|
||||
class CachedImage;
|
||||
class Attachment;
|
||||
NativeContext* nativeContext = nullptr;
|
||||
OpenGLRenderer* renderer = nullptr;
|
||||
double currentRenderScale = 1.0;
|
||||
std::unique_ptr<Attachment> attachment;
|
||||
OpenGLPixelFormat openGLPixelFormat;
|
||||
|
||||
void* contextToShareWith = nullptr;
|
||||
OpenGLVersion versionRequired = defaultGLVersion;
|
||||
size_t imageCacheMaxSize = 8 * 1024 * 1024;
|
||||
bool renderComponents = true, useMultisampling = false, overrideCanAttach = false;
|
||||
std::atomic<bool> continuousRepaint { false };
|
||||
TextureMagnificationFilter texMagFilter = linear;
|
||||
bool mobileBufferBugMitigation = false;
|
||||
|
||||
//==============================================================================
|
||||
struct AsyncWorker : public ReferenceCountedObject
|
||||
{
|
||||
using Ptr = ReferenceCountedObjectPtr<AsyncWorker>;
|
||||
virtual void operator() (OpenGLContext&) = 0;
|
||||
~AsyncWorker() override = default;
|
||||
};
|
||||
|
||||
template <typename FunctionType>
|
||||
struct AsyncWorkerFunctor : public AsyncWorker
|
||||
{
|
||||
AsyncWorkerFunctor (FunctionType functorToUse) : functor (functorToUse) {}
|
||||
void operator() (OpenGLContext& callerContext) override { functor (callerContext); }
|
||||
FunctionType functor;
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE (AsyncWorkerFunctor)
|
||||
};
|
||||
|
||||
//==============================================================================
|
||||
CachedImage* getCachedImage() const noexcept;
|
||||
void execute (AsyncWorker::Ptr, bool);
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (OpenGLContext)
|
||||
};
|
||||
|
||||
//==============================================================================
|
||||
#ifndef DOXYGEN
|
||||
template <typename FunctionType>
|
||||
void OpenGLContext::executeOnGLThread (FunctionType&& f, bool shouldBlock) { execute (new AsyncWorkerFunctor<FunctionType> (f), shouldBlock); }
|
||||
#endif
|
||||
|
||||
} // namespace juce
|
||||
Reference in New Issue
Block a user