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.
737 Commits
11 Branches
3.6GB
Tree: 2fee27c757
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2fee27c757'
${ noResults }
JUCE/build/win32/platform_specific_code/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-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.         int x, y, w, h;

  292.         nativeWindow->getBounds (x, y, w, h);

  293.         nativeWindow->repaint (0, 0, w, h);

  294.     }

  295. 

  296.     void swapBuffers()

  297.     {

  298.         SwapBuffers (dc);

  299.     }

  300. 

  301.     bool setSwapInterval (const int numFramesPerSwap)

  302.     {

  303.         makeActive();

  304. 

  305.         StringArray availableExtensions;

  306.         getWglExtensions (dc, availableExtensions);

  307. 

  308.         PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = 0;

  309. 

  310.         return availableExtensions.contains ("WGL_EXT_swap_control")

  311.                 && WGL_EXT_FUNCTION_INIT (PFNWGLSWAPINTERVALEXTPROC, wglSwapIntervalEXT)

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

  313.     }

  314. 

  315.     int getSwapInterval() const

  316.     {

  317.         makeActive();

  318. 

  319.         StringArray availableExtensions;

  320.         getWglExtensions (dc, availableExtensions);

  321. 

  322.         PFNWGLGETSWAPINTERVALEXTPROC wglGetSwapIntervalEXT = 0;

  323. 

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

  325.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETSWAPINTERVALEXTPROC, wglGetSwapIntervalEXT))

  326.             return wglGetSwapIntervalEXT();

  327. 

  328.         return 0;

  329.     }

  330. 

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

  332.     {

  333.         jassert (isActive());

  334. 

  335.         StringArray availableExtensions;

  336.         getWglExtensions (dc, availableExtensions);

  337. 

  338.         PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB = 0;

  339.         int numTypes = 0;

  340. 

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

  342.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETPIXELFORMATATTRIBIVARBPROC, wglGetPixelFormatAttribivARB))

  343.         {

  344.             int attributes = WGL_NUMBER_PIXEL_FORMATS_ARB;

  345. 

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

  347.                 jassertfalse

  348.         }

  349.         else

  350.         {

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

  352.         }

  353. 

  354.         OpenGLPixelFormat pf;

  355. 

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

  357.         {

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

  359.             {

  360.                 bool alreadyListed = false;

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

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

  363.                         alreadyListed = true;

  364. 

  365.                 if (! alreadyListed)

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

  367.             }

  368.         }

  369.     }

  370. 

  371.     void* getNativeWindowHandle() const

  372.     {

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

  374.     }

  375. 

  376.     //==============================================================================

  377.     juce_UseDebuggingNewOperator

  378. 

  379.     HGLRC renderContext;

  380. 

  381. private:

  382.     Win32ComponentPeer* nativeWindow;

  383.     Component* const component;

  384.     HDC dc;

  385. 

  386.     //==============================================================================

  387.     void createNativeWindow()

  388.     {

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

  390.         nativeWindow->dontRepaint = true;

  391.         nativeWindow->setVisible (true);

  392. 

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

  394. 

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

  396. 

  397.         if (peer != 0)

  398.         {

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

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

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

  402.         }

  403. 

  404.         dc = GetDC (hwnd);

  405.     }

  406. 

  407.     bool fillInPixelFormatDetails (const int pixelFormatIndex,

  408.                                    OpenGLPixelFormat& result,

  409.                                    const StringArray& availableExtensions) const throw()

  410.     {

  411.         PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB = 0;

  412. 

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

  414.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETPIXELFORMATATTRIBIVARBPROC, wglGetPixelFormatAttribivARB))

  415.         {

  416.             int attributes[32];

  417.             int numAttributes = 0;

  418. 

  419.             attributes[numAttributes++] = WGL_DRAW_TO_WINDOW_ARB;

  420.             attributes[numAttributes++] = WGL_SUPPORT_OPENGL_ARB;

  421.             attributes[numAttributes++] = WGL_ACCELERATION_ARB;

  422.             attributes[numAttributes++] = WGL_DOUBLE_BUFFER_ARB;

  423.             attributes[numAttributes++] = WGL_PIXEL_TYPE_ARB;

  424.             attributes[numAttributes++] = WGL_RED_BITS_ARB;

  425.             attributes[numAttributes++] = WGL_GREEN_BITS_ARB;

  426.             attributes[numAttributes++] = WGL_BLUE_BITS_ARB;

  427.             attributes[numAttributes++] = WGL_ALPHA_BITS_ARB;

  428.             attributes[numAttributes++] = WGL_DEPTH_BITS_ARB;

  429.             attributes[numAttributes++] = WGL_STENCIL_BITS_ARB;

  430.             attributes[numAttributes++] = WGL_ACCUM_RED_BITS_ARB;

  431.             attributes[numAttributes++] = WGL_ACCUM_GREEN_BITS_ARB;

  432.             attributes[numAttributes++] = WGL_ACCUM_BLUE_BITS_ARB;

  433.             attributes[numAttributes++] = WGL_ACCUM_ALPHA_BITS_ARB;

  434. 

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

  436.                 attributes[numAttributes++] = WGL_SAMPLES_ARB;

  437. 

  438.             int values[32];

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

  440. 

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

  442.             {

  443.                 int n = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  460. 

  461.                 return isValidFormat;

  462.             }

  463.             else

  464.             {

  465.                 jassertfalse

  466.             }

  467.         }

  468.         else

  469.         {

  470.             PIXELFORMATDESCRIPTOR pfd;

  471. 

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

  473.             {

  474.                 result.redBits = pfd.cRedBits;

  475.                 result.greenBits = pfd.cGreenBits;

  476.                 result.blueBits = pfd.cBlueBits;

  477.                 result.alphaBits = pfd.cAlphaBits;

  478.                 result.depthBufferBits = pfd.cDepthBits;

  479.                 result.stencilBufferBits = pfd.cStencilBits;

  480.                 result.accumulationBufferRedBits = pfd.cAccumRedBits;

  481.                 result.accumulationBufferGreenBits = pfd.cAccumGreenBits;

  482.                 result.accumulationBufferBlueBits = pfd.cAccumBlueBits;

  483.                 result.accumulationBufferAlphaBits = pfd.cAccumAlphaBits;

  484.                 result.fullSceneAntiAliasingNumSamples = 0;

  485. 

  486.                 return true;

  487.             }

  488.             else

  489.             {

  490.                 jassertfalse

  491.             }

  492.         }

  493. 

  494.         return false;

  495.     }

  496. 

  497.     WindowedGLContext (const WindowedGLContext&);

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

  499. };

  500. 

  501. //==============================================================================

  502. OpenGLContext* OpenGLContext::createContextForWindow (Component* const component,

  503.                                                       const OpenGLPixelFormat& pixelFormat,

  504.                                                       const OpenGLContext* const contextToShareWith)

  505. {

  506.     WindowedGLContext* c = new WindowedGLContext (component,

  507.                                                   contextToShareWith != 0 ? (HGLRC) contextToShareWith->getRawContext() : 0,

  508.                                                   pixelFormat);

  509. 

  510.     if (c->renderContext == 0)

  511.         deleteAndZero (c);

  512. 

  513.     return c;

  514. }

  515. 

  516. void* OpenGLComponent::getNativeWindowHandle() const

  517. {

  518.     return context != 0 ? ((WindowedGLContext*) 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