juce/source/src/gui/components/special/juce_OpenGLComponent.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../../core/juce_StandardHeader.h"
  27
  28 #if JUCE_OPENGL
  29
  30 BEGIN_JUCE_NAMESPACE
  31
  32 #include "juce_OpenGLComponent.h"
  33 #include "../windows/juce_ComponentPeer.h"
  34 #include "../layout/juce_ComponentMovementWatcher.h"
  35 #include "../../../threads/juce_Thread.h"
  36
  37
  38 //==============================================================================
  39 extern void juce_glViewport (const int w, const int h);
  40
  41
  42 //==============================================================================
  43 OpenGLPixelFormat::OpenGLPixelFormat (const int bitsPerRGBComponent,
  44                                       const int alphaBits_,
  45                                       const int depthBufferBits_,
  46                                       const int stencilBufferBits_)
  47     : redBits (bitsPerRGBComponent),
  48       greenBits (bitsPerRGBComponent),
  49       blueBits (bitsPerRGBComponent),
  50       alphaBits (alphaBits_),
  51       depthBufferBits (depthBufferBits_),
  52       stencilBufferBits (stencilBufferBits_),
  53       accumulationBufferRedBits (0),
  54       accumulationBufferGreenBits (0),
  55       accumulationBufferBlueBits (0),
  56       accumulationBufferAlphaBits (0),
  57       fullSceneAntiAliasingNumSamples (0)
  58 {
  59 }
  60
  61 OpenGLPixelFormat::OpenGLPixelFormat (const OpenGLPixelFormat& other)
  62     : redBits (other.redBits),
  63       greenBits (other.greenBits),
  64       blueBits (other.blueBits),
  65       alphaBits (other.alphaBits),
  66       depthBufferBits (other.depthBufferBits),
  67       stencilBufferBits (other.stencilBufferBits),
  68       accumulationBufferRedBits (other.accumulationBufferRedBits),
  69       accumulationBufferGreenBits (other.accumulationBufferGreenBits),
  70       accumulationBufferBlueBits (other.accumulationBufferBlueBits),
  71       accumulationBufferAlphaBits (other.accumulationBufferAlphaBits),
  72       fullSceneAntiAliasingNumSamples (other.fullSceneAntiAliasingNumSamples)
  73 {
  74 }
  75
  76 OpenGLPixelFormat& OpenGLPixelFormat::operator= (const OpenGLPixelFormat& other)
  77 {
  78     redBits = other.redBits;
  79     greenBits = other.greenBits;
  80     blueBits = other.blueBits;
  81     alphaBits = other.alphaBits;
  82     depthBufferBits = other.depthBufferBits;
  83     stencilBufferBits = other.stencilBufferBits;
  84     accumulationBufferRedBits = other.accumulationBufferRedBits;
  85     accumulationBufferGreenBits = other.accumulationBufferGreenBits;
  86     accumulationBufferBlueBits = other.accumulationBufferBlueBits;
  87     accumulationBufferAlphaBits = other.accumulationBufferAlphaBits;
  88     fullSceneAntiAliasingNumSamples = other.fullSceneAntiAliasingNumSamples;
  89     return *this;
  90 }
  91
  92 bool OpenGLPixelFormat::operator== (const OpenGLPixelFormat& other) const
  93 {
  94     return redBits == other.redBits
  95             && greenBits == other.greenBits
  96             && blueBits == other.blueBits
  97             && alphaBits == other.alphaBits
  98             && depthBufferBits == other.depthBufferBits
  99             && stencilBufferBits == other.stencilBufferBits
 100             && accumulationBufferRedBits == other.accumulationBufferRedBits
 101             && accumulationBufferGreenBits == other.accumulationBufferGreenBits
 102             && accumulationBufferBlueBits == other.accumulationBufferBlueBits
 103             && accumulationBufferAlphaBits == other.accumulationBufferAlphaBits
 104             && fullSceneAntiAliasingNumSamples == other.fullSceneAntiAliasingNumSamples;
 105 }
 106
 107 //==============================================================================
 108 static Array<OpenGLContext*> knownContexts;
 109
 110 OpenGLContext::OpenGLContext() noexcept
 111 {
 112     knownContexts.add (this);
 113 }
 114
 115 OpenGLContext::~OpenGLContext()
 116 {
 117     knownContexts.removeValue (this);
 118 }
 119
 120 OpenGLContext* OpenGLContext::getCurrentContext()
 121 {
 122     for (int i = knownContexts.size(); --i >= 0;)
 123     {
 124         OpenGLContext* const oglc = knownContexts.getUnchecked(i);
 125
 126         if (oglc->isActive())
 127             return oglc;
 128     }
 129
 130     return nullptr;
 131 }
 132
 133 //==============================================================================
 134 class OpenGLComponent::OpenGLComponentWatcher  : public ComponentMovementWatcher
 135 {
 136 public:
 137     //==============================================================================
 138     OpenGLComponentWatcher (OpenGLComponent* const owner_)
 139         : ComponentMovementWatcher (owner_),
 140           owner (owner_)
 141     {
 142     }
 143
 144     //==============================================================================
 145     void componentMovedOrResized (bool /*wasMoved*/, bool /*wasResized*/)
 146     {
 147         owner->updateContextPosition();
 148     }
 149
 150     void componentPeerChanged()
 151     {
 152         owner->recreateContextAsync();
 153     }
 154
 155     void componentVisibilityChanged()
 156     {
 157         if (! owner->isShowing())
 158             owner->stopBackgroundThread();
 159     }
 160
 161     //==============================================================================
 162 private:
 163     OpenGLComponent* const owner;
 164
 165     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (OpenGLComponentWatcher);
 166 };
 167
 168 //==============================================================================
 169 class OpenGLComponent::OpenGLComponentRenderThread  : public Thread
 170 {
 171 public:
 172     OpenGLComponentRenderThread (OpenGLComponent& owner_)
 173         : Thread ("OpenGL Render"),
 174           owner (owner_)
 175     {
 176     }
 177
 178     void run()
 179     {
 180         while (! threadShouldExit())
 181         {
 182             const uint32 startOfRendering = Time::getMillisecondCounter();
 183
 184             if (! owner.renderAndSwapBuffers())
 185                 break;
 186
 187             const int elapsed = Time::getMillisecondCounter() - startOfRendering;
 188             Thread::sleep (jmax (1, 20 - elapsed));
 189         }
 190
 191        #if JUCE_LINUX
 192         owner.deleteContext();
 193        #endif
 194     }
 195
 196 private:
 197     OpenGLComponent& owner;
 198
 199     JUCE_DECLARE_NON_COPYABLE (OpenGLComponentRenderThread);
 200 };
 201
 202 void OpenGLComponent::startRenderThread()
 203 {
 204     if (renderThread == nullptr)
 205         renderThread = new OpenGLComponentRenderThread (*this);
 206
 207     renderThread->startThread (6);
 208 }
 209
 210 void OpenGLComponent::stopRenderThread()
 211 {
 212     if (renderThread != nullptr)
 213     {
 214         renderThread->stopThread (5000);
 215         renderThread = nullptr;
 216     }
 217
 218    #if ! JUCE_LINUX
 219     deleteContext();
 220    #endif
 221 }
 222
 223 //==============================================================================
 224 OpenGLComponent::OpenGLComponent (const OpenGLType type_, const bool useBackgroundThread)
 225     : type (type_),
 226       contextToShareListsWith (nullptr),
 227       needToUpdateViewport (true),
 228       needToDeleteContext (false),
 229       threadStarted (false),
 230       useThread (useBackgroundThread)
 231 {
 232     setOpaque (true);
 233     componentWatcher = new OpenGLComponentWatcher (this);
 234 }
 235
 236 OpenGLComponent::~OpenGLComponent()
 237 {
 238     stopBackgroundThread();
 239     componentWatcher = nullptr;
 240 }
 241
 242 const OpenGLPixelFormat OpenGLComponent::getPixelFormat() const
 243 {
 244     OpenGLPixelFormat pf;
 245
 246     const ScopedLock sl (contextLock);
 247     if (context != nullptr)
 248         pf = context->getPixelFormat();
 249
 250     return pf;
 251 }
 252
 253 void OpenGLComponent::setPixelFormat (const OpenGLPixelFormat& formatToUse)
 254 {
 255     if (! (preferredPixelFormat == formatToUse))
 256     {
 257         const ScopedLock sl (contextLock);
 258         preferredPixelFormat = formatToUse;
 259         recreateContextAsync();
 260     }
 261 }
 262
 263 void OpenGLComponent::shareWith (OpenGLContext* c)
 264 {
 265     if (contextToShareListsWith != c)
 266     {
 267         const ScopedLock sl (contextLock);
 268         contextToShareListsWith = c;
 269         recreateContextAsync();
 270     }
 271 }
 272
 273 void OpenGLComponent::recreateContextAsync()
 274 {
 275     const ScopedLock sl (contextLock);
 276     needToDeleteContext = true;
 277     repaint();
 278 }
 279
 280 bool OpenGLComponent::makeCurrentContextActive()
 281 {
 282     return context != nullptr && context->makeActive();
 283 }
 284
 285 void OpenGLComponent::makeCurrentContextInactive()
 286 {
 287     if (context != nullptr)
 288         context->makeInactive();
 289 }
 290
 291 bool OpenGLComponent::isActiveContext() const noexcept
 292 {
 293     return context != nullptr && context->isActive();
 294 }
 295
 296 void OpenGLComponent::swapBuffers()
 297 {
 298     if (context != nullptr)
 299         context->swapBuffers();
 300 }
 301
 302 void OpenGLComponent::updateContext()
 303 {
 304     if (needToDeleteContext)
 305         deleteContext();
 306
 307     if (context == nullptr)
 308     {
 309         const ScopedLock sl (contextLock);
 310
 311         if (context == nullptr)
 312         {
 313             context = createContext();
 314
 315             if (context != nullptr)
 316             {
 317                #if JUCE_LINUX
 318                 if (! useThread)
 319                #endif
 320                     updateContextPosition();
 321
 322                 if (context->makeActive())
 323                 {
 324                     newOpenGLContextCreated();
 325                     context->makeInactive();
 326                 }
 327             }
 328         }
 329     }
 330 }
 331
 332 void OpenGLComponent::deleteContext()
 333 {
 334     const ScopedLock sl (contextLock);
 335     if (context != nullptr)
 336     {
 337         if (context->makeActive())
 338         {
 339             releaseOpenGLContext();
 340             context->makeInactive();
 341         }
 342
 343         context = nullptr;
 344     }
 345
 346     needToDeleteContext = false;
 347 }
 348
 349 void OpenGLComponent::updateContextPosition()
 350 {
 351     needToUpdateViewport = true;
 352
 353     if (getWidth() > 0 && getHeight() > 0)
 354     {
 355         Component* const topComp = getTopLevelComponent();
 356
 357         if (topComp->getPeer() != nullptr)
 358         {
 359             const ScopedLock sl (contextLock);
 360
 361             if (context != nullptr)
 362                 context->updateWindowPosition (topComp->getLocalArea (this, getLocalBounds()));
 363         }
 364     }
 365 }
 366
 367 void OpenGLComponent::stopBackgroundThread()
 368 {
 369     if (threadStarted)
 370     {
 371         stopRenderThread();
 372         threadStarted = false;
 373     }
 374 }
 375
 376 void OpenGLComponent::paint (Graphics&)
 377 {
 378     ComponentPeer* const peer = getPeer();
 379
 380     if (useThread)
 381     {
 382         if (peer != nullptr && isShowing())
 383         {
 384            #if ! JUCE_LINUX
 385             updateContext();
 386            #endif
 387
 388             if (! threadStarted)
 389             {
 390                 threadStarted = true;
 391                 startRenderThread();
 392             }
 393         }
 394     }
 395     else
 396     {
 397         updateContext();
 398
 399         if (! renderAndSwapBuffers())
 400             return;
 401     }
 402
 403     if (peer != nullptr)
 404     {
 405         const Point<int> topLeft (getScreenPosition() - peer->getScreenPosition());
 406         peer->addMaskedRegion (topLeft.getX(), topLeft.getY(), getWidth(), getHeight());
 407     }
 408 }
 409
 410 bool OpenGLComponent::renderAndSwapBuffers()
 411 {
 412     const ScopedLock sl (contextLock);
 413
 414    #if JUCE_LINUX
 415     updateContext();
 416    #endif
 417
 418     if (context != nullptr)
 419     {
 420         if (! makeCurrentContextActive())
 421             return false;
 422
 423         if (needToUpdateViewport)
 424         {
 425             needToUpdateViewport = false;
 426             juce_glViewport (getWidth(), getHeight());
 427         }
 428
 429         renderOpenGL();
 430         swapBuffers();
 431     }
 432
 433     return true;
 434 }
 435
 436 void OpenGLComponent::internalRepaint (int x, int y, int w, int h)
 437 {
 438     Component::internalRepaint (x, y, w, h);
 439
 440     if (context != nullptr)
 441         context->repaint();
 442 }
 443
 444
 445 END_JUCE_NAMESPACE
 446
 447 #endif