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.
1043 Commits
11 Branches
808MB
Tree: 4f704c4d33
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4f704c4d33'
${ noResults }
JUCE/src/native/windows/juce_win32_OpenGLComponent.cpp

534 lines
20KB
Raw Blame History 

  1. /*

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

  3. 

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

  5.    Copyright 2004-9 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.           nativeWindow (0),

  85.           dc (0),

  86.           component (component_)

  87.     {

  88.         jassert (component != 0);

  89. 

  90.         createNativeWindow();

  91. 

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

  93.         PIXELFORMATDESCRIPTOR pfd;

  94.         zerostruct (pfd);

  95.         pfd.nSize = sizeof (pfd);

  96.         pfd.nVersion = 1;

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

  98.         pfd.iPixelType = PFD_TYPE_RGBA;

  99.         pfd.cColorBits = 24;

  100.         pfd.cDepthBits = 16;

  101. 

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

  103. 

  104.         if (format != 0)

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

  106. 

  107.         renderContext = wglCreateContext (dc);

  108.         makeActive();

  109. 

  110.         setPixelFormat (pixelFormat);

  111. 

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

  113.             wglShareLists (contextToShareWith, renderContext);

  114.     }

  115. 

  116.     ~WindowedGLContext()

  117.     {

  118.         makeInactive();

  119. 

  120.         wglDeleteContext (renderContext);

  121. 

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

  123.         delete nativeWindow;

  124.     }

  125. 

  126.     bool makeActive() const throw()

  127.     {

  128.         jassert (renderContext != 0);

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

  130.     }

  131. 

  132.     bool makeInactive() const throw()

  133.     {

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

  135.     }

  136. 

  137.     bool isActive() const throw()

  138.     {

  139.         return wglGetCurrentContext() == renderContext;

  140.     }

  141. 

  142.     const OpenGLPixelFormat getPixelFormat() const

  143.     {

  144.         OpenGLPixelFormat pf;

  145. 

  146.         makeActive();

  147.         StringArray availableExtensions;

  148.         getWglExtensions (dc, availableExtensions);

  149. 

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

  151.         return pf;

  152.     }

  153. 

  154.     void* getRawContext() const throw()

  155.     {

  156.         return renderContext;

  157.     }

  158. 

  159.     bool setPixelFormat (const OpenGLPixelFormat& pixelFormat)

  160.     {

  161.         makeActive();

  162. 

  163.         PIXELFORMATDESCRIPTOR pfd;

  164.         zerostruct (pfd);

  165.         pfd.nSize = sizeof (pfd);

  166.         pfd.nVersion = 1;

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

  168.         pfd.iPixelType = PFD_TYPE_RGBA;

  169.         pfd.iLayerType = PFD_MAIN_PLANE;

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

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

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

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

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

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

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

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

  178.                                     + pixelFormat.accumulationBufferBlueBits + pixelFormat.accumulationBufferAlphaBits);

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

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

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

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

  183. 

  184.         int format = 0;

  185. 

  186.         PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = 0;

  187. 

  188.         StringArray availableExtensions;

  189.         getWglExtensions (dc, availableExtensions);

  190. 

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

  192.              && WGL_EXT_FUNCTION_INIT (PFNWGLCHOOSEPIXELFORMATARBPROC, wglChoosePixelFormatARB))

  193.         {

  194.             int attributes[64];

  195.             int n = 0;

  196. 

  197.             attributes[n++] = WGL_DRAW_TO_WINDOW_ARB;

  198.             attributes[n++] = GL_TRUE;

  199.             attributes[n++] = WGL_SUPPORT_OPENGL_ARB;

  200.             attributes[n++] = GL_TRUE;

  201.             attributes[n++] = WGL_ACCELERATION_ARB;

  202.             attributes[n++] = WGL_FULL_ACCELERATION_ARB;

  203.             attributes[n++] = WGL_DOUBLE_BUFFER_ARB;

  204.             attributes[n++] = GL_TRUE;

  205.             attributes[n++] = WGL_PIXEL_TYPE_ARB;

  206.             attributes[n++] = WGL_TYPE_RGBA_ARB;

  207. 

  208.             attributes[n++] = WGL_COLOR_BITS_ARB;

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

  210.             attributes[n++] = WGL_RED_BITS_ARB;

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

  212.             attributes[n++] = WGL_GREEN_BITS_ARB;

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

  214.             attributes[n++] = WGL_BLUE_BITS_ARB;

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

  216.             attributes[n++] = WGL_ALPHA_BITS_ARB;

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

  218.             attributes[n++] = WGL_DEPTH_BITS_ARB;

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

  220. 

  221.             if (pixelFormat.stencilBufferBits > 0)

  222.             {

  223.                 attributes[n++] = WGL_STENCIL_BITS_ARB;

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

  225.             }

  226. 

  227.             attributes[n++] = WGL_ACCUM_RED_BITS_ARB;

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

  229.             attributes[n++] = WGL_ACCUM_GREEN_BITS_ARB;

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

  231.             attributes[n++] = WGL_ACCUM_BLUE_BITS_ARB;

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

  233.             attributes[n++] = WGL_ACCUM_ALPHA_BITS_ARB;

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

  235. 

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

  237.                  && pixelFormat.fullSceneAntiAliasingNumSamples > 0)

  238.             {

  239.                 attributes[n++] = WGL_SAMPLE_BUFFERS_ARB;

  240.                 attributes[n++] = 1;

  241.                 attributes[n++] = WGL_SAMPLES_ARB;

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

  243.             }

  244. 

  245.             attributes[n++] = 0;

  246. 

  247.             UINT formatsCount;

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

  249.             (void) ok;

  250.             jassert (ok);

  251.         }

  252.         else

  253.         {

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

  255.         }

  256. 

  257.         if (format != 0)

  258.         {

  259.             makeInactive();

  260. 

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

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

  263.             jassert (nativeWindow != 0);

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

  265.             delete nativeWindow;

  266. 

  267.             createNativeWindow();

  268. 

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

  270.             {

  271.                 wglDeleteContext (renderContext);

  272.                 renderContext = wglCreateContext (dc);

  273. 

  274.                 jassert (renderContext != 0);

  275.                 return renderContext != 0;

  276.             }

  277.         }

  278. 

  279.         return false;

  280.     }

  281. 

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

  283.     {

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

  285.                       x, y, w, h,

  286.                       SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOOWNERZORDER);

  287.     }

  288. 

  289.     void repaint()

  290.     {

  291.         const Rectangle<int> bounds (nativeWindow->getBounds());

  292.         nativeWindow->repaint (0, 0, bounds.getWidth(), bounds.getHeight());

  293.     }

  294. 

  295.     void swapBuffers()

  296.     {

  297.         SwapBuffers (dc);

  298.     }

  299. 

  300.     bool setSwapInterval (int numFramesPerSwap)

  301.     {

  302.         makeActive();

  303. 

  304.         StringArray availableExtensions;

  305.         getWglExtensions (dc, availableExtensions);

  306. 

  307.         PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = 0;

  308. 

  309.         return availableExtensions.contains ("WGL_EXT_swap_control")

  310.                 && WGL_EXT_FUNCTION_INIT (PFNWGLSWAPINTERVALEXTPROC, wglSwapIntervalEXT)

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

  312.     }

  313. 

  314.     int getSwapInterval() const

  315.     {

  316.         makeActive();

  317. 

  318.         StringArray availableExtensions;

  319.         getWglExtensions (dc, availableExtensions);

  320. 

  321.         PFNWGLGETSWAPINTERVALEXTPROC wglGetSwapIntervalEXT = 0;

  322. 

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

  324.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETSWAPINTERVALEXTPROC, wglGetSwapIntervalEXT))

  325.             return wglGetSwapIntervalEXT();

  326. 

  327.         return 0;

  328.     }

  329. 

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

  331.     {

  332.         jassert (isActive());

  333. 

  334.         StringArray availableExtensions;

  335.         getWglExtensions (dc, availableExtensions);

  336. 

  337.         PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB = 0;

  338.         int numTypes = 0;

  339. 

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

  341.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETPIXELFORMATATTRIBIVARBPROC, wglGetPixelFormatAttribivARB))

  342.         {

  343.             int attributes = WGL_NUMBER_PIXEL_FORMATS_ARB;

  344. 

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

  346.                 jassertfalse

  347.         }

  348.         else

  349.         {

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

  351.         }

  352. 

  353.         OpenGLPixelFormat pf;

  354. 

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

  356.         {

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

  358.             {

  359.                 bool alreadyListed = false;

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

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

  362.                         alreadyListed = true;

  363. 

  364.                 if (! alreadyListed)

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

  366.             }

  367.         }

  368.     }

  369. 

  370.     void* getNativeWindowHandle() const

  371.     {

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

  373.     }

  374. 

  375.     //==============================================================================

  376.     juce_UseDebuggingNewOperator

  377. 

  378.     HGLRC renderContext;

  379. 

  380. private:

  381.     Win32ComponentPeer* nativeWindow;

  382.     Component* const component;

  383.     HDC dc;

  384. 

  385.     //==============================================================================

  386.     void createNativeWindow()

  387.     {

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

  389.         nativeWindow->dontRepaint = true;

  390.         nativeWindow->setVisible (true);

  391. 

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

  393. 

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

  395. 

  396.         if (peer != 0)

  397.         {

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

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

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

  401.         }

  402. 

  403.         dc = GetDC (hwnd);

  404.     }

  405. 

  406.     bool fillInPixelFormatDetails (const int pixelFormatIndex,

  407.                                    OpenGLPixelFormat& result,

  408.                                    const StringArray& availableExtensions) const throw()

  409.     {

  410.         PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB = 0;

  411. 

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

  413.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETPIXELFORMATATTRIBIVARBPROC, wglGetPixelFormatAttribivARB))

  414.         {

  415.             int attributes[32];

  416.             int numAttributes = 0;

  417. 

  418.             attributes[numAttributes++] = WGL_DRAW_TO_WINDOW_ARB;

  419.             attributes[numAttributes++] = WGL_SUPPORT_OPENGL_ARB;

  420.             attributes[numAttributes++] = WGL_ACCELERATION_ARB;

  421.             attributes[numAttributes++] = WGL_DOUBLE_BUFFER_ARB;

  422.             attributes[numAttributes++] = WGL_PIXEL_TYPE_ARB;

  423.             attributes[numAttributes++] = WGL_RED_BITS_ARB;

  424.             attributes[numAttributes++] = WGL_GREEN_BITS_ARB;

  425.             attributes[numAttributes++] = WGL_BLUE_BITS_ARB;

  426.             attributes[numAttributes++] = WGL_ALPHA_BITS_ARB;

  427.             attributes[numAttributes++] = WGL_DEPTH_BITS_ARB;

  428.             attributes[numAttributes++] = WGL_STENCIL_BITS_ARB;

  429.             attributes[numAttributes++] = WGL_ACCUM_RED_BITS_ARB;

  430.             attributes[numAttributes++] = WGL_ACCUM_GREEN_BITS_ARB;

  431.             attributes[numAttributes++] = WGL_ACCUM_BLUE_BITS_ARB;

  432.             attributes[numAttributes++] = WGL_ACCUM_ALPHA_BITS_ARB;

  433. 

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

  435.                 attributes[numAttributes++] = WGL_SAMPLES_ARB;

  436. 

  437.             int values[32];

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

  439. 

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

  441.             {

  442.                 int n = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  459. 

  460.                 return isValidFormat;

  461.             }

  462.             else

  463.             {

  464.                 jassertfalse

  465.             }

  466.         }

  467.         else

  468.         {

  469.             PIXELFORMATDESCRIPTOR pfd;

  470. 

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

  472.             {

  473.                 result.redBits = pfd.cRedBits;

  474.                 result.greenBits = pfd.cGreenBits;

  475.                 result.blueBits = pfd.cBlueBits;

  476.                 result.alphaBits = pfd.cAlphaBits;

  477.                 result.depthBufferBits = pfd.cDepthBits;

  478.                 result.stencilBufferBits = pfd.cStencilBits;

  479.                 result.accumulationBufferRedBits = pfd.cAccumRedBits;

  480.                 result.accumulationBufferGreenBits = pfd.cAccumGreenBits;

  481.                 result.accumulationBufferBlueBits = pfd.cAccumBlueBits;

  482.                 result.accumulationBufferAlphaBits = pfd.cAccumAlphaBits;

  483.                 result.fullSceneAntiAliasingNumSamples = 0;

  484. 

  485.                 return true;

  486.             }

  487.             else

  488.             {

  489.                 jassertfalse

  490.             }

  491.         }

  492. 

  493.         return false;

  494.     }

  495. 

  496.     WindowedGLContext (const WindowedGLContext&);

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

  498. };

  499. 

  500. //==============================================================================

  501. OpenGLContext* OpenGLComponent::createContext()

  502. {

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

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

  505.                                                                preferredPixelFormat));

  506. 

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

  508. }

  509. 

  510. void* OpenGLComponent::getNativeWindowHandle() const

  511. {

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

  513. }

  514. 

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

  516. {

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

  518. }

  519. 

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

  521.                                                   OwnedArray <OpenGLPixelFormat>& results)

  522. {

  523.     Component tempComp;

  524. 

  525.     {

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

  527.         wc.makeActive();

  528.         wc.findAlternativeOpenGLPixelFormats (results);

  529.     }

  530. }

  531. 

  532. 

  533. #endif