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.
633 Commits
9 Branches
413MB
Tree: d85394d1bd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd85394d1bd'
${ noResults }
JUCE/build/win32/platform_specific_code/juce_win32_OpenGLComponent.cpp

546 lines
21KB
Raw Blame History 

  1. /*

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

  3. 

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

  5.    Copyright 2004-7 by Raw Material Software ltd.

  6. 

  7.   ------------------------------------------------------------------------------

  8. 

  9.    JUCE can be redistributed and/or modified under the terms of the

  10.    GNU General Public License, as published by the Free Software Foundation;

  11.    either version 2 of the License, or (at your option) any later version.

  12. 

  13.    JUCE is distributed in the hope that it will be useful,

  14.    but WITHOUT ANY WARRANTY; without even the implied warranty of

  15.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  16.    GNU General Public License for more details.

  17. 

  18.    You should have received a copy of the GNU General Public License

  19.    along with JUCE; if not, visit www.gnu.org/licenses or write to the

  20.    Free Software Foundation, Inc., 59 Temple Place, Suite 330,

  21.    Boston, MA 02111-1307 USA

  22. 

  23.   ------------------------------------------------------------------------------

  24. 

  25.    If you'd like to release a closed-source product which uses JUCE, commercial

  26.    licenses are also available: visit www.rawmaterialsoftware.com/juce for

  27.    more information.

  28. 

  29.   ==============================================================================

  30. */

  31. 

  32. // (This file gets included by juce_win32_NativeCode.cpp, rather than being

  33. // compiled on its own).

  34. #if JUCE_INCLUDED_FILE && JUCE_OPENGL

  35. 

  36. 

  37. //==============================================================================

  38. #define WGL_EXT_FUNCTION_INIT(extType, extFunc) \

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

  40. 

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

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

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

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

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

  46. 

  47. #define WGL_NUMBER_PIXEL_FORMATS_ARB    0x2000

  48. #define WGL_DRAW_TO_WINDOW_ARB          0x2001

  49. #define WGL_ACCELERATION_ARB            0x2003

  50. #define WGL_SWAP_METHOD_ARB             0x2007

  51. #define WGL_SUPPORT_OPENGL_ARB          0x2010

  52. #define WGL_PIXEL_TYPE_ARB              0x2013

  53. #define WGL_DOUBLE_BUFFER_ARB           0x2011

  54. #define WGL_COLOR_BITS_ARB              0x2014

  55. #define WGL_RED_BITS_ARB                0x2015

  56. #define WGL_GREEN_BITS_ARB              0x2017

  57. #define WGL_BLUE_BITS_ARB               0x2019

  58. #define WGL_ALPHA_BITS_ARB              0x201B

  59. #define WGL_DEPTH_BITS_ARB              0x2022

  60. #define WGL_STENCIL_BITS_ARB            0x2023

  61. #define WGL_FULL_ACCELERATION_ARB       0x2027

  62. #define WGL_ACCUM_RED_BITS_ARB          0x201E

  63. #define WGL_ACCUM_GREEN_BITS_ARB        0x201F

  64. #define WGL_ACCUM_BLUE_BITS_ARB         0x2020

  65. #define WGL_ACCUM_ALPHA_BITS_ARB        0x2021

  66. #define WGL_STEREO_ARB                  0x2012

  67. #define WGL_SAMPLE_BUFFERS_ARB          0x2041

  68. #define WGL_SAMPLES_ARB                 0x2042

  69. #define WGL_TYPE_RGBA_ARB               0x202B

  70. 

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

  72. {

  73.     PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = 0;

  74. 

  75.     if (WGL_EXT_FUNCTION_INIT (PFNWGLGETEXTENSIONSSTRINGARBPROC, wglGetExtensionsStringARB))

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

  77.     else

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

  79. }

  80. 

  81. 

  82. //==============================================================================

  83. class WindowedGLContext     : public OpenGLContext

  84. {

  85. public:

  86.     WindowedGLContext (Component* const component_,

  87.                        HGLRC contextToShareWith,

  88.                        const OpenGLPixelFormat& pixelFormat)

  89.         : renderContext (0),

  90.           nativeWindow (0),

  91.           dc (0),

  92.           component (component_)

  93.     {

  94.         jassert (component != 0);

  95. 

  96.         createNativeWindow();

  97. 

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

  99.         PIXELFORMATDESCRIPTOR pfd;

  100.         zerostruct (pfd);

  101.         pfd.nSize = sizeof (pfd);

  102.         pfd.nVersion = 1;

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

  104.         pfd.iPixelType = PFD_TYPE_RGBA;

  105.         pfd.cColorBits = 24;

  106.         pfd.cDepthBits = 16;

  107. 

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

  109. 

  110.         if (format != 0)

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

  112. 

  113.         renderContext = wglCreateContext (dc);

  114.         makeActive();

  115. 

  116.         setPixelFormat (pixelFormat);

  117. 

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

  119.             wglShareLists (contextToShareWith, renderContext);

  120.     }

  121. 

  122.     ~WindowedGLContext()

  123.     {

  124.         makeInactive();

  125. 

  126.         wglDeleteContext (renderContext);

  127. 

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

  129.         delete nativeWindow;

  130.     }

  131. 

  132.     bool makeActive() const throw()

  133.     {

  134.         jassert (renderContext != 0);

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

  136.     }

  137. 

  138.     bool makeInactive() const throw()

  139.     {

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

  141.     }

  142. 

  143.     bool isActive() const throw()

  144.     {

  145.         return wglGetCurrentContext() == renderContext;

  146.     }

  147. 

  148.     const OpenGLPixelFormat getPixelFormat() const

  149.     {

  150.         OpenGLPixelFormat pf;

  151. 

  152.         makeActive();

  153.         StringArray availableExtensions;

  154.         getWglExtensions (dc, availableExtensions);

  155. 

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

  157.         return pf;

  158.     }

  159. 

  160.     void* getRawContext() const throw()

  161.     {

  162.         return renderContext;

  163.     }

  164. 

  165.     bool setPixelFormat (const OpenGLPixelFormat& pixelFormat)

  166.     {

  167.         makeActive();

  168. 

  169.         PIXELFORMATDESCRIPTOR pfd;

  170.         zerostruct (pfd);

  171.         pfd.nSize = sizeof (pfd);

  172.         pfd.nVersion = 1;

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

  174.         pfd.iPixelType = PFD_TYPE_RGBA;

  175.         pfd.iLayerType = PFD_MAIN_PLANE;

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

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

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

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

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

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

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

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

  184.                                     + pixelFormat.accumulationBufferBlueBits + pixelFormat.accumulationBufferAlphaBits);

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

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

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

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

  189. 

  190.         int format = 0;

  191. 

  192.         PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = 0;

  193. 

  194.         StringArray availableExtensions;

  195.         getWglExtensions (dc, availableExtensions);

  196. 

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

  198.              && WGL_EXT_FUNCTION_INIT (PFNWGLCHOOSEPIXELFORMATARBPROC, wglChoosePixelFormatARB))

  199.         {

  200.             int attributes[64];

  201.             int n = 0;

  202. 

  203.             attributes[n++] = WGL_DRAW_TO_WINDOW_ARB;

  204.             attributes[n++] = GL_TRUE;

  205.             attributes[n++] = WGL_SUPPORT_OPENGL_ARB;

  206.             attributes[n++] = GL_TRUE;

  207.             attributes[n++] = WGL_ACCELERATION_ARB;

  208.             attributes[n++] = WGL_FULL_ACCELERATION_ARB;

  209.             attributes[n++] = WGL_DOUBLE_BUFFER_ARB;

  210.             attributes[n++] = GL_TRUE;

  211.             attributes[n++] = WGL_PIXEL_TYPE_ARB;

  212.             attributes[n++] = WGL_TYPE_RGBA_ARB;

  213. 

  214.             attributes[n++] = WGL_COLOR_BITS_ARB;

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

  216.             attributes[n++] = WGL_RED_BITS_ARB;

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

  218.             attributes[n++] = WGL_GREEN_BITS_ARB;

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

  220.             attributes[n++] = WGL_BLUE_BITS_ARB;

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

  222.             attributes[n++] = WGL_ALPHA_BITS_ARB;

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

  224.             attributes[n++] = WGL_DEPTH_BITS_ARB;

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

  226. 

  227.             if (pixelFormat.stencilBufferBits > 0)

  228.             {

  229.                 attributes[n++] = WGL_STENCIL_BITS_ARB;

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

  231.             }

  232. 

  233.             attributes[n++] = WGL_ACCUM_RED_BITS_ARB;

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

  235.             attributes[n++] = WGL_ACCUM_GREEN_BITS_ARB;

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

  237.             attributes[n++] = WGL_ACCUM_BLUE_BITS_ARB;

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

  239.             attributes[n++] = WGL_ACCUM_ALPHA_BITS_ARB;

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

  241. 

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

  243.                  && pixelFormat.fullSceneAntiAliasingNumSamples > 0)

  244.             {

  245.                 attributes[n++] = WGL_SAMPLE_BUFFERS_ARB;

  246.                 attributes[n++] = 1;

  247.                 attributes[n++] = WGL_SAMPLES_ARB;

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

  249.             }

  250. 

  251.             attributes[n++] = 0;

  252. 

  253.             UINT formatsCount;

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

  255.             (void) ok;

  256.             jassert (ok);

  257.         }

  258.         else

  259.         {

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

  261.         }

  262. 

  263.         if (format != 0)

  264.         {

  265.             makeInactive();

  266. 

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

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

  269.             jassert (nativeWindow != 0);

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

  271.             delete nativeWindow;

  272. 

  273.             createNativeWindow();

  274. 

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

  276.             {

  277.                 wglDeleteContext (renderContext);

  278.                 renderContext = wglCreateContext (dc);

  279. 

  280.                 jassert (renderContext != 0);

  281.                 return renderContext != 0;

  282.             }

  283.         }

  284. 

  285.         return false;

  286.     }

  287. 

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

  289.     {

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

  291.                       x, y, w, h,

  292.                       SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOOWNERZORDER);

  293.     }

  294. 

  295.     void repaint()

  296.     {

  297.         int x, y, w, h;

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

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

  300.     }

  301. 

  302.     void swapBuffers()

  303.     {

  304.         SwapBuffers (dc);

  305.     }

  306. 

  307.     bool setSwapInterval (const int numFramesPerSwap)

  308.     {

  309.         makeActive();

  310. 

  311.         StringArray availableExtensions;

  312.         getWglExtensions (dc, availableExtensions);

  313. 

  314.         PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = 0;

  315. 

  316.         return availableExtensions.contains ("WGL_EXT_swap_control")

  317.                 && WGL_EXT_FUNCTION_INIT (PFNWGLSWAPINTERVALEXTPROC, wglSwapIntervalEXT)

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

  319.     }

  320. 

  321.     int getSwapInterval() const

  322.     {

  323.         makeActive();

  324. 

  325.         StringArray availableExtensions;

  326.         getWglExtensions (dc, availableExtensions);

  327. 

  328.         PFNWGLGETSWAPINTERVALEXTPROC wglGetSwapIntervalEXT = 0;

  329. 

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

  331.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETSWAPINTERVALEXTPROC, wglGetSwapIntervalEXT))

  332.             return wglGetSwapIntervalEXT();

  333. 

  334.         return 0;

  335.     }

  336. 

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

  338.     {

  339.         jassert (isActive());

  340. 

  341.         StringArray availableExtensions;

  342.         getWglExtensions (dc, availableExtensions);

  343. 

  344.         PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB = 0;

  345.         int numTypes = 0;

  346. 

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

  348.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETPIXELFORMATATTRIBIVARBPROC, wglGetPixelFormatAttribivARB))

  349.         {

  350.             int attributes = WGL_NUMBER_PIXEL_FORMATS_ARB;

  351. 

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

  353.                 jassertfalse

  354.         }

  355.         else

  356.         {

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

  358.         }

  359. 

  360.         OpenGLPixelFormat pf;

  361. 

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

  363.         {

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

  365.             {

  366.                 bool alreadyListed = false;

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

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

  369.                         alreadyListed = true;

  370. 

  371.                 if (! alreadyListed)

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

  373.             }

  374.         }

  375.     }

  376. 

  377.     void* getNativeWindowHandle() const

  378.     {

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

  380.     }

  381. 

  382.     //==============================================================================

  383.     juce_UseDebuggingNewOperator

  384. 

  385.     HGLRC renderContext;

  386. 

  387. private:

  388.     Win32ComponentPeer* nativeWindow;

  389.     Component* const component;

  390.     HDC dc;

  391. 

  392.     //==============================================================================

  393.     void createNativeWindow()

  394.     {

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

  396.         nativeWindow->dontRepaint = true;

  397.         nativeWindow->setVisible (true);

  398. 

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

  400. 

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

  402. 

  403.         if (peer != 0)

  404.         {

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

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

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

  408.         }

  409. 

  410.         dc = GetDC (hwnd);

  411.     }

  412. 

  413.     bool fillInPixelFormatDetails (const int pixelFormatIndex,

  414.                                    OpenGLPixelFormat& result,

  415.                                    const StringArray& availableExtensions) const throw()

  416.     {

  417.         PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB = 0;

  418. 

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

  420.              && WGL_EXT_FUNCTION_INIT (PFNWGLGETPIXELFORMATATTRIBIVARBPROC, wglGetPixelFormatAttribivARB))

  421.         {

  422.             int attributes[32];

  423.             int numAttributes = 0;

  424. 

  425.             attributes[numAttributes++] = WGL_DRAW_TO_WINDOW_ARB;

  426.             attributes[numAttributes++] = WGL_SUPPORT_OPENGL_ARB;

  427.             attributes[numAttributes++] = WGL_ACCELERATION_ARB;

  428.             attributes[numAttributes++] = WGL_DOUBLE_BUFFER_ARB;

  429.             attributes[numAttributes++] = WGL_PIXEL_TYPE_ARB;

  430.             attributes[numAttributes++] = WGL_RED_BITS_ARB;

  431.             attributes[numAttributes++] = WGL_GREEN_BITS_ARB;

  432.             attributes[numAttributes++] = WGL_BLUE_BITS_ARB;

  433.             attributes[numAttributes++] = WGL_ALPHA_BITS_ARB;

  434.             attributes[numAttributes++] = WGL_DEPTH_BITS_ARB;

  435.             attributes[numAttributes++] = WGL_STENCIL_BITS_ARB;

  436.             attributes[numAttributes++] = WGL_ACCUM_RED_BITS_ARB;

  437.             attributes[numAttributes++] = WGL_ACCUM_GREEN_BITS_ARB;

  438.             attributes[numAttributes++] = WGL_ACCUM_BLUE_BITS_ARB;

  439.             attributes[numAttributes++] = WGL_ACCUM_ALPHA_BITS_ARB;

  440. 

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

  442.                 attributes[numAttributes++] = WGL_SAMPLES_ARB;

  443. 

  444.             int values[32];

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

  446. 

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

  448.             {

  449.                 int n = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  466. 

  467.                 return isValidFormat;

  468.             }

  469.             else

  470.             {

  471.                 jassertfalse

  472.             }

  473.         }

  474.         else

  475.         {

  476.             PIXELFORMATDESCRIPTOR pfd;

  477. 

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

  479.             {

  480.                 result.redBits = pfd.cRedBits;

  481.                 result.greenBits = pfd.cGreenBits;

  482.                 result.blueBits = pfd.cBlueBits;

  483.                 result.alphaBits = pfd.cAlphaBits;

  484.                 result.depthBufferBits = pfd.cDepthBits;

  485.                 result.stencilBufferBits = pfd.cStencilBits;

  486.                 result.accumulationBufferRedBits = pfd.cAccumRedBits;

  487.                 result.accumulationBufferGreenBits = pfd.cAccumGreenBits;

  488.                 result.accumulationBufferBlueBits = pfd.cAccumBlueBits;

  489.                 result.accumulationBufferAlphaBits = pfd.cAccumAlphaBits;

  490.                 result.fullSceneAntiAliasingNumSamples = 0;

  491. 

  492.                 return true;

  493.             }

  494.             else

  495.             {

  496.                 jassertfalse

  497.             }

  498.         }

  499. 

  500.         return false;

  501.     }

  502. 

  503.     WindowedGLContext (const WindowedGLContext&);

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

  505. };

  506. 

  507. //==============================================================================

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

  509.                                                       const OpenGLPixelFormat& pixelFormat,

  510.                                                       const OpenGLContext* const contextToShareWith)

  511. {

  512.     WindowedGLContext* c = new WindowedGLContext (component,

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

  514.                                                   pixelFormat);

  515. 

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

  517.         deleteAndZero (c);

  518. 

  519.     return c;

  520. }

  521. 

  522. void* OpenGLComponent::getNativeWindowHandle() const

  523. {

  524.     return context != 0 ? ((WindowedGLContext*) context)->getNativeWindowHandle() : 0;

  525. }

  526. 

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

  528. {

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

  530. }

  531. 

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

  533.                                                   OwnedArray <OpenGLPixelFormat>& results)

  534. {

  535.     Component tempComp;

  536. 

  537.     {

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

  539.         wc.makeActive();

  540.         wc.findAlternativeOpenGLPixelFormats (results);

  541.     }

  542. }

  543. 

  544. 

  545. #endif