DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1211 Commits
9 Branches
6.1GB
Tree: 23e07daec7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '23e07daec7'
${ noResults }
JUCE/src/native/windows/juce_win32_OpenGLComponent.cpp

540 lines
20KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library - "Jules' Utility Class Extensions"

  5.    Copyright 2004-10 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. // (This file gets included by juce_win32_NativeCode.cpp, rather than being

  27. // compiled on its own).

  28. #if JUCE_INCLUDED_FILE && JUCE_OPENGL

  29. 

  30. 

  31. //==============================================================================

  32. #define WGL_EXT_FUNCTION_INIT(extType, extFunc) \

  33.     ((extFunc = (extType) wglGetProcAddress (#extFunc)) != 0)

  34. 

  35. typedef const char* (WINAPI* PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);

  36. typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);

  37. typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int* piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);

  38. typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);

  39. typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void);

  40. 

  41. #define WGL_NUMBER_PIXEL_FORMATS_ARB    0x2000

  42. #define WGL_DRAW_TO_WINDOW_ARB          0x2001

  43. #define WGL_ACCELERATION_ARB            0x2003

  44. #define WGL_SWAP_METHOD_ARB             0x2007

  45. #define WGL_SUPPORT_OPENGL_ARB          0x2010

  46. #define WGL_PIXEL_TYPE_ARB              0x2013

  47. #define WGL_DOUBLE_BUFFER_ARB           0x2011

  48. #define WGL_COLOR_BITS_ARB              0x2014

  49. #define WGL_RED_BITS_ARB                0x2015

  50. #define WGL_GREEN_BITS_ARB              0x2017

  51. #define WGL_BLUE_BITS_ARB               0x2019

  52. #define WGL_ALPHA_BITS_ARB              0x201B

  53. #define WGL_DEPTH_BITS_ARB              0x2022

  54. #define WGL_STENCIL_BITS_ARB            0x2023

  55. #define WGL_FULL_ACCELERATION_ARB       0x2027

  56. #define WGL_ACCUM_RED_BITS_ARB          0x201E

  57. #define WGL_ACCUM_GREEN_BITS_ARB        0x201F

  58. #define WGL_ACCUM_BLUE_BITS_ARB         0x2020

  59. #define WGL_ACCUM_ALPHA_BITS_ARB        0x2021

  60. #define WGL_STEREO_ARB                  0x2012

  61. #define WGL_SAMPLE_BUFFERS_ARB          0x2041

  62. #define WGL_SAMPLES_ARB                 0x2042

  63. #define WGL_TYPE_RGBA_ARB               0x202B

  64. 

  65. static void getWglExtensions (HDC dc, StringArray& result) throw()

  66. {

  67.     PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = 0;

  68. 

  69.     if (WGL_EXT_FUNCTION_INIT (PFNWGLGETEXTENSIONSSTRINGARBPROC, wglGetExtensionsStringARB))

  70.         result.addTokens (String (wglGetExtensionsStringARB (dc)), false);

  71.     else

  72.         jassertfalse; // If this fails, it may be because you didn't activate the openGL context

  73. }

  74. 

  75. 

  76. //==============================================================================

  77. class WindowedGLContext     : public OpenGLContext

  78. {

  79. public:

  80.     WindowedGLContext (Component* const component_,

  81.                        HGLRC contextToShareWith,

  82.                        const OpenGLPixelFormat& pixelFormat)

  83.         : renderContext (0),

  84.           dc (0),

  85.           component (component_)

  86.     {

  87.         jassert (component != 0);

  88. 

  89.         createNativeWindow();

  90. 

  91.         // Use a default pixel format that should be supported everywhere

  92.         PIXELFORMATDESCRIPTOR pfd;

  93.         zerostruct (pfd);

  94.         pfd.nSize = sizeof (pfd);

  95.         pfd.nVersion = 1;

  96.         pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;

  97.         pfd.iPixelType = PFD_TYPE_RGBA;

  98.         pfd.cColorBits = 24;

  99.         pfd.cDepthBits = 16;

  100. 

  101.         const int format = ChoosePixelFormat (dc, &pfd);

  102. 

  103.         if (format != 0)

  104.             SetPixelFormat (dc, format, &pfd);

  105. 

  106.         renderContext = wglCreateContext (dc);

  107.         makeActive();

  108. 

  109.         setPixelFormat (pixelFormat);

  110. 

  111.         if (contextToShareWith != 0 && renderContext != 0)

  112.             wglShareLists (contextToShareWith, renderContext);

  113.     }

  114. 

  115.     ~WindowedGLContext()

  116.     {

  117.         deleteContext();

  118.         ReleaseDC ((HWND) nativeWindow->getNativeHandle(), dc);

  119.         nativeWindow = 0;

  120.     }

  121. 

  122.     void deleteContext()

  123.     {

  124.         makeInactive();

  125. 

  126.         if (renderContext != 0)

  127.         {

  128.             wglDeleteContext (renderContext);

  129.             renderContext = 0;

  130.         }

  131.     }

  132. 

  133.     bool makeActive() const throw()

  134.     {

  135.         jassert (renderContext != 0);

  136.         return wglMakeCurrent (dc, renderContext) != 0;

  137.     }

  138. 

  139.     bool makeInactive() const throw()

  140.     {

  141.         return (! isActive()) || (wglMakeCurrent (0, 0) != 0);

  142.     }

  143. 

  144.     bool isActive() const throw()

  145.     {

  146.         return wglGetCurrentContext() == renderContext;

  147.     }

  148. 

  149.     const OpenGLPixelFormat getPixelFormat() const

  150.     {

  151.         OpenGLPixelFormat pf;

  152. 

  153.         makeActive();

  154.         StringArray availableExtensions;

  155.         getWglExtensions (dc, availableExtensions);

  156. 

  157.         fillInPixelFormatDetails (GetPixelFormat (dc), pf, availableExtensions);

  158.         return pf;

  159.     }

  160. 

  161.     void* getRawContext() const throw()

  162.     {

  163.         return renderContext;

  164.     }

  165. 

  166.     bool setPixelFormat (const OpenGLPixelFormat& pixelFormat)

  167.     {

  168.         makeActive();

  169. 

  170.         PIXELFORMATDESCRIPTOR pfd;

  171.         zerostruct (pfd);

  172.         pfd.nSize = sizeof (pfd);

  173.         pfd.nVersion = 1;

  174.         pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER;

  175.         pfd.iPixelType = PFD_TYPE_RGBA;

  176.         pfd.iLayerType = PFD_MAIN_PLANE;

  177.         pfd.cColorBits = (BYTE) (pixelFormat.redBits + pixelFormat.greenBits + pixelFormat.blueBits);

  178.         pfd.cRedBits = (BYTE) pixelFormat.redBits;

  179.         pfd.cGreenBits = (BYTE) pixelFormat.greenBits;

  180.         pfd.cBlueBits = (BYTE) pixelFormat.blueBits;

  181.         pfd.cAlphaBits = (BYTE) pixelFormat.alphaBits;

  182.         pfd.cDepthBits = (BYTE) pixelFormat.depthBufferBits;

  183.         pfd.cStencilBits = (BYTE) pixelFormat.stencilBufferBits;

  184.         pfd.cAccumBits = (BYTE) (pixelFormat.accumulationBufferRedBits + pixelFormat.accumulationBufferGreenBits

  185.                                     + pixelFormat.accumulationBufferBlueBits + pixelFormat.accumulationBufferAlphaBits);

  186.         pfd.cAccumRedBits = (BYTE) pixelFormat.accumulationBufferRedBits;

  187.         pfd.cAccumGreenBits = (BYTE) pixelFormat.accumulationBufferGreenBits;

  188.         pfd.cAccumBlueBits = (BYTE) pixelFormat.accumulationBufferBlueBits;

  189.         pfd.cAccumAlphaBits = (BYTE) pixelFormat.accumulationBufferAlphaBits;

  190. 

  191.         int format = 0;

  192. 

  193.         PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = 0;

  194. 

  195.         StringArray availableExtensions;

  196.         getWglExtensions (dc, availableExtensions);

  197. 

  198.         if (availableExtensions.contains ("WGL_ARB_pixel_format")

  199.              && WGL_EXT_FUNCTION_INIT (PFNWGLCHOOSEPIXELFORMATARBPROC, wglChoosePixelFormatARB))

  200.         {

  201.             int attributes[64];

  202.             int n = 0;

  203. 

  204.             attributes[n++] = WGL_DRAW_TO_WINDOW_ARB;

  205.             attributes[n++] = GL_TRUE;

  206.             attributes[n++] = WGL_SUPPORT_OPENGL_ARB;

  207.             attributes[n++] = GL_TRUE;

  208.             attributes[n++] = WGL_ACCELERATION_ARB;

  209.             attributes[n++] = WGL_FULL_ACCELERATION_ARB;

  210.             attributes[n++] = WGL_DOUBLE_BUFFER_ARB;

  211.             attributes[n++] = GL_TRUE;

  212.             attributes[n++] = WGL_PIXEL_TYPE_ARB;

  213.             attributes[n++] = WGL_TYPE_RGBA_ARB;

  214. 

  215.             attributes[n++] = WGL_COLOR_BITS_ARB;

  216.             attributes[n++] = pfd.cColorBits;

  217.             attributes[n++] = WGL_RED_BITS_ARB;

  218.             attributes[n++] = pixelFormat.redBits;

  219.             attributes[n++] = WGL_GREEN_BITS_ARB;

  220.             attributes[n++] = pixelFormat.greenBits;

  221.             attributes[n++] = WGL_BLUE_BITS_ARB;

  222.             attributes[n++] = pixelFormat.blueBits;

  223.             attributes[n++] = WGL_ALPHA_BITS_ARB;

  224.             attributes[n++] = pixelFormat.alphaBits;

  225.             attributes[n++] = WGL_DEPTH_BITS_ARB;

  226.             attributes[n++] = pixelFormat.depthBufferBits;

  227. 

  228.             if (pixelFormat.stencilBufferBits > 0)

  229.             {

  230.                 attributes[n++] = WGL_STENCIL_BITS_ARB;

  231.                 attributes[n++] = pixelFormat.stencilBufferBits;

  232.             }

  233. 

  234.             attributes[n++] = WGL_ACCUM_RED_BITS_ARB;

  235.             attributes[n++] = pixelFormat.accumulationBufferRedBits;

  236.             attributes[n++] = WGL_ACCUM_GREEN_BITS_ARB;

  237.             attributes[n++] = pixelFormat.accumulationBufferGreenBits;

  238.             attributes[n++] = WGL_ACCUM_BLUE_BITS_ARB;

  239.             attributes[n++] = pixelFormat.accumulationBufferBlueBits;

  240.             attributes[n++] = WGL_ACCUM_ALPHA_BITS_ARB;

  241.             attributes[n++] = pixelFormat.accumulationBufferAlphaBits;

  242. 

  243.             if (availableExtensions.contains ("WGL_ARB_multisample")

  244.                  && pixelFormat.fullSceneAntiAliasingNumSamples > 0)

  245.             {

  246.                 attributes[n++] = WGL_SAMPLE_BUFFERS_ARB;

  247.                 attributes[n++] = 1;

  248.                 attributes[n++] = WGL_SAMPLES_ARB;

  249.                 attributes[n++] = pixelFormat.fullSceneAntiAliasingNumSamples;

  250.             }

  251. 

  252.             attributes[n++] = 0;

  253. 

  254.             UINT formatsCount;

  255.             const BOOL ok = wglChoosePixelFormatARB (dc, attributes, 0, 1, &format, &formatsCount);

  256.             (void) ok;

  257.             jassert (ok);

  258.         }

  259.         else

  260.         {

  261.             format = ChoosePixelFormat (dc, &pfd);

  262.         }

  263. 

  264.         if (format != 0)

  265.         {

  266.             makeInactive();

  267. 

  268.             // win32 can't change the pixel format of a window, so need to delete the

  269.             // old one and create a new one..

  270.             jassert (nativeWindow != 0);

  271.             ReleaseDC ((HWND) nativeWindow->getNativeHandle(), dc);

  272.             nativeWindow = 0;

  273. 

  274.             createNativeWindow();

  275. 

  276.             if (SetPixelFormat (dc, format, &pfd))

  277.             {

  278.                 wglDeleteContext (renderContext);

  279.                 renderContext = wglCreateContext (dc);

  280. 

  281.                 jassert (renderContext != 0);

  282.                 return renderContext != 0;

  283.             }

  284.         }

  285. 

  286.         return false;

  287.     }

  288. 

  289.     void updateWindowPosition (int x, int y, int w, int h, int)

  290.     {

  291.         SetWindowPos ((HWND) nativeWindow->getNativeHandle(), 0,

  292.                       x, y, w, h,

  293.                       SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOOWNERZORDER);

  294.     }

  295. 

  296.     void repaint()

  297.     {

  298.         nativeWindow->repaint (nativeWindow->getBounds().withPosition (Point<int>()));

  299.     }

  300. 

  301.     void swapBuffers()

  302.     {

  303.         SwapBuffers (dc);

  304.     }

  305. 

  306.     bool setSwapInterval (int numFramesPerSwap)

  307.     {

  308.         makeActive();

  309. 

  310.         StringArray availableExtensions;

  311.         getWglExtensions (dc, availableExtensions);

  312. 

  313.         PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = 0;

  314. 

  315.         return availableExtensions.contains ("WGL_EXT_swap_control")

  316.                 && WGL_EXT_FUNCTION_INIT (PFNWGLSWAPINTERVALEXTPROC, wglSwapIntervalEXT)

  317.                 && wglSwapIntervalEXT (numFramesPerSwap) != FALSE;

  318.     }

  319. 

  320.     int getSwapInterval() const

  321.     {

  322.         makeActive();

  323. 

  324.         StringArray availableExtensions;

  325.         getWglExtensions (dc, availableExtensions);

  326. 

  327.         PFNWGLGETSWAPINTERVALEXTPROC wglGetSwapIntervalEXT = 0;

  328. 

  329.         if (availableExtensions.contains ("WGL_EXT_swap_control")

  330.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETSWAPINTERVALEXTPROC, wglGetSwapIntervalEXT))

  331.             return wglGetSwapIntervalEXT();

  332. 

  333.         return 0;

  334.     }

  335. 

  336.     void findAlternativeOpenGLPixelFormats (OwnedArray <OpenGLPixelFormat>& results)

  337.     {

  338.         jassert (isActive());

  339. 

  340.         StringArray availableExtensions;

  341.         getWglExtensions (dc, availableExtensions);

  342. 

  343.         PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB = 0;

  344.         int numTypes = 0;

  345. 

  346.         if (availableExtensions.contains("WGL_ARB_pixel_format")

  347.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETPIXELFORMATATTRIBIVARBPROC, wglGetPixelFormatAttribivARB))

  348.         {

  349.             int attributes = WGL_NUMBER_PIXEL_FORMATS_ARB;

  350. 

  351.             if (! wglGetPixelFormatAttribivARB (dc, 1, 0, 1, &attributes, &numTypes))

  352.                 jassertfalse;

  353.         }

  354.         else

  355.         {

  356.             numTypes = DescribePixelFormat (dc, 0, 0, 0);

  357.         }

  358. 

  359.         OpenGLPixelFormat pf;

  360. 

  361.         for (int i = 0; i < numTypes; ++i)

  362.         {

  363.             if (fillInPixelFormatDetails (i + 1, pf, availableExtensions))

  364.             {

  365.                 bool alreadyListed = false;

  366.                 for (int j = results.size(); --j >= 0;)

  367.                     if (pf == *results.getUnchecked(j))

  368.                         alreadyListed = true;

  369. 

  370.                 if (! alreadyListed)

  371.                     results.add (new OpenGLPixelFormat (pf));

  372.             }

  373.         }

  374.     }

  375. 

  376.     void* getNativeWindowHandle() const

  377.     {

  378.         return nativeWindow != 0 ? nativeWindow->getNativeHandle() : 0;

  379.     }

  380. 

  381.     //==============================================================================

  382.     juce_UseDebuggingNewOperator

  383. 

  384.     HGLRC renderContext;

  385. 

  386. private:

  387.     ScopedPointer<Win32ComponentPeer> nativeWindow;

  388.     Component* const component;

  389.     HDC dc;

  390. 

  391.     //==============================================================================

  392.     void createNativeWindow()

  393.     {

  394.         nativeWindow = new Win32ComponentPeer (component, 0);

  395.         nativeWindow->dontRepaint = true;

  396.         nativeWindow->setVisible (true);

  397. 

  398.         HWND hwnd = (HWND) nativeWindow->getNativeHandle();

  399. 

  400.         Win32ComponentPeer* const peer = dynamic_cast <Win32ComponentPeer*> (component->getTopLevelComponent()->getPeer());

  401. 

  402.         if (peer != 0)

  403.         {

  404.             SetParent (hwnd, (HWND) peer->getNativeHandle());

  405.             juce_setWindowStyleBit (hwnd, GWL_STYLE, WS_CHILD, true);

  406.             juce_setWindowStyleBit (hwnd, GWL_STYLE, WS_POPUP, false);

  407.         }

  408. 

  409.         dc = GetDC (hwnd);

  410.     }

  411. 

  412.     bool fillInPixelFormatDetails (const int pixelFormatIndex,

  413.                                    OpenGLPixelFormat& result,

  414.                                    const StringArray& availableExtensions) const throw()

  415.     {

  416.         PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB = 0;

  417. 

  418.         if (availableExtensions.contains ("WGL_ARB_pixel_format")

  419.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETPIXELFORMATATTRIBIVARBPROC, wglGetPixelFormatAttribivARB))

  420.         {

  421.             int attributes[32];

  422.             int numAttributes = 0;

  423. 

  424.             attributes[numAttributes++] = WGL_DRAW_TO_WINDOW_ARB;

  425.             attributes[numAttributes++] = WGL_SUPPORT_OPENGL_ARB;

  426.             attributes[numAttributes++] = WGL_ACCELERATION_ARB;

  427.             attributes[numAttributes++] = WGL_DOUBLE_BUFFER_ARB;

  428.             attributes[numAttributes++] = WGL_PIXEL_TYPE_ARB;

  429.             attributes[numAttributes++] = WGL_RED_BITS_ARB;

  430.             attributes[numAttributes++] = WGL_GREEN_BITS_ARB;

  431.             attributes[numAttributes++] = WGL_BLUE_BITS_ARB;

  432.             attributes[numAttributes++] = WGL_ALPHA_BITS_ARB;

  433.             attributes[numAttributes++] = WGL_DEPTH_BITS_ARB;

  434.             attributes[numAttributes++] = WGL_STENCIL_BITS_ARB;

  435.             attributes[numAttributes++] = WGL_ACCUM_RED_BITS_ARB;

  436.             attributes[numAttributes++] = WGL_ACCUM_GREEN_BITS_ARB;

  437.             attributes[numAttributes++] = WGL_ACCUM_BLUE_BITS_ARB;

  438.             attributes[numAttributes++] = WGL_ACCUM_ALPHA_BITS_ARB;

  439. 

  440.             if (availableExtensions.contains ("WGL_ARB_multisample"))

  441.                 attributes[numAttributes++] = WGL_SAMPLES_ARB;

  442. 

  443.             int values[32];

  444.             zeromem (values, sizeof (values));

  445. 

  446.             if (wglGetPixelFormatAttribivARB (dc, pixelFormatIndex, 0, numAttributes, attributes, values))

  447.             {

  448.                 int n = 0;

  449.                 bool isValidFormat = (values[n++] == GL_TRUE);      // WGL_DRAW_TO_WINDOW_ARB

  450.                 isValidFormat = (values[n++] == GL_TRUE) && isValidFormat;   // WGL_SUPPORT_OPENGL_ARB

  451.                 isValidFormat = (values[n++] == WGL_FULL_ACCELERATION_ARB) && isValidFormat; // WGL_ACCELERATION_ARB

  452.                 isValidFormat = (values[n++] == GL_TRUE) && isValidFormat;   // WGL_DOUBLE_BUFFER_ARB:

  453.                 isValidFormat = (values[n++] == WGL_TYPE_RGBA_ARB) && isValidFormat; // WGL_PIXEL_TYPE_ARB

  454.                 result.redBits = values[n++];           // WGL_RED_BITS_ARB

  455.                 result.greenBits = values[n++];         // WGL_GREEN_BITS_ARB

  456.                 result.blueBits = values[n++];          // WGL_BLUE_BITS_ARB

  457.                 result.alphaBits = values[n++];         // WGL_ALPHA_BITS_ARB

  458.                 result.depthBufferBits = values[n++];   // WGL_DEPTH_BITS_ARB

  459.                 result.stencilBufferBits = values[n++]; // WGL_STENCIL_BITS_ARB

  460.                 result.accumulationBufferRedBits = values[n++];      // WGL_ACCUM_RED_BITS_ARB

  461.                 result.accumulationBufferGreenBits = values[n++];    // WGL_ACCUM_GREEN_BITS_ARB

  462.                 result.accumulationBufferBlueBits = values[n++];     // WGL_ACCUM_BLUE_BITS_ARB

  463.                 result.accumulationBufferAlphaBits = values[n++];    // WGL_ACCUM_ALPHA_BITS_ARB

  464.                 result.fullSceneAntiAliasingNumSamples = (uint8) values[n++];       // WGL_SAMPLES_ARB

  465. 

  466.                 return isValidFormat;

  467.             }

  468.             else

  469.             {

  470.                 jassertfalse;

  471.             }

  472.         }

  473.         else

  474.         {

  475.             PIXELFORMATDESCRIPTOR pfd;

  476. 

  477.             if (DescribePixelFormat (dc, pixelFormatIndex, sizeof (pfd), &pfd))

  478.             {

  479.                 result.redBits = pfd.cRedBits;

  480.                 result.greenBits = pfd.cGreenBits;

  481.                 result.blueBits = pfd.cBlueBits;

  482.                 result.alphaBits = pfd.cAlphaBits;

  483.                 result.depthBufferBits = pfd.cDepthBits;

  484.                 result.stencilBufferBits = pfd.cStencilBits;

  485.                 result.accumulationBufferRedBits = pfd.cAccumRedBits;

  486.                 result.accumulationBufferGreenBits = pfd.cAccumGreenBits;

  487.                 result.accumulationBufferBlueBits = pfd.cAccumBlueBits;

  488.                 result.accumulationBufferAlphaBits = pfd.cAccumAlphaBits;

  489.                 result.fullSceneAntiAliasingNumSamples = 0;

  490. 

  491.                 return true;

  492.             }

  493.             else

  494.             {

  495.                 jassertfalse;

  496.             }

  497.         }

  498. 

  499.         return false;

  500.     }

  501. 

  502.     WindowedGLContext (const WindowedGLContext&);

  503.     WindowedGLContext& operator= (const WindowedGLContext&);

  504. };

  505. 

  506. //==============================================================================

  507. OpenGLContext* OpenGLComponent::createContext()

  508. {

  509.     ScopedPointer<WindowedGLContext> c (new WindowedGLContext (this,

  510.                                                                contextToShareListsWith != 0 ? (HGLRC) contextToShareListsWith->getRawContext() : 0,

  511.                                                                preferredPixelFormat));

  512. 

  513.     return (c->renderContext != 0) ? c.release() : 0;

  514. }

  515. 

  516. void* OpenGLComponent::getNativeWindowHandle() const

  517. {

  518.     return context != 0 ? static_cast<WindowedGLContext*> (static_cast<OpenGLContext*> (context))->getNativeWindowHandle() : 0;

  519. }

  520. 

  521. void juce_glViewport (const int w, const int h)

  522. {

  523.     glViewport (0, 0, w, h);

  524. }

  525. 

  526. void OpenGLPixelFormat::getAvailablePixelFormats (Component* component,

  527.                                                   OwnedArray <OpenGLPixelFormat>& results)

  528. {

  529.     Component tempComp;

  530. 

  531.     {

  532.         WindowedGLContext wc (component, 0, OpenGLPixelFormat (8, 8, 16, 0));

  533.         wc.makeActive();

  534.         wc.findAlternativeOpenGLPixelFormats (results);

  535.     }

  536. }

  537. 

  538. 

  539. #endif