/////////////////////////////////////////////////////////////////////////////
-// Name: glcanvas.cpp
-// Purpose: wxGLCanvas, for using OpenGL with wxWindows under MS Windows
+// Name: src/msw/glcanvas.cpp
+// Purpose: wxGLCanvas, for using OpenGL with wxWidgets under MS Windows
// Author: Julian Smart
// Modified by:
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
-// Licence: wxWindows licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "glcanvas.h"
#endif
#pragma hdrstop
#endif
-#include <wx/setup.h>
-
#if wxUSE_GLCANVAS
#ifndef WX_PRECOMP
-#include <wx/frame.h>
+ #include "wx/frame.h"
+ #include "wx/settings.h"
+ #include "wx/intl.h"
+ #include "wx/log.h"
+ #include "wx/app.h"
#endif
-#include <wx/msw/private.h>
-#include <wx/settings.h>
-#include <wx/log.h>
+#include "wx/module.h"
+
+#include "wx/msw/private.h"
-#include <wx/glcanvas.h>
+// DLL options compatibility check:
+#include "wx/build.h"
+WX_CHECK_BUILD_OPTIONS("wxGL")
-wxChar wxGLCanvasClassName[] = wxT("wxGLCanvasClass");
+#include "wx/glcanvas.h"
+
+#if GL_EXT_vertex_array
+ #define WXUNUSED_WITHOUT_GL_EXT_vertex_array(name) name
+#else
+ #define WXUNUSED_WITHOUT_GL_EXT_vertex_array(name) WXUNUSED(name)
+#endif
+
+/*
+ The following two compiler directives are specific to the Microsoft Visual
+ C++ family of compilers
+
+ Fundementally what they do is instruct the linker to use these two libraries
+ for the resolution of symbols. In essence, this is the equivalent of adding
+ these two libraries to either the Makefile or project file.
+
+ This is NOT a recommended technique, and certainly is unlikely to be used
+ anywhere else in wxWidgets given it is so specific to not only wxMSW, but
+ also the VC compiler. However, in the case of opengl support, it's an
+ applicable technique as opengl is optional in setup.h This code (wrapped by
+ wxUSE_GLCANVAS), now allows opengl support to be added purely by modifying
+ setup.h rather than by having to modify either the project or DSP fle.
+
+ See MSDN for further information on the exact usage of these commands.
+*/
+#ifdef _MSC_VER
+# pragma comment( lib, "opengl32" )
+# pragma comment( lib, "glu32" )
+#endif
+
+
+static const wxChar *wxGLCanvasClassName = wxT("wxGLCanvasClass");
+static const wxChar *wxGLCanvasClassNameNoRedraw = wxT("wxGLCanvasClassNR");
LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam);
+// ----------------------------------------------------------------------------
+// wxGLModule is responsible for unregistering wxGLCanvasClass Windows class
+// ----------------------------------------------------------------------------
+
+class wxGLModule : public wxModule
+{
+public:
+ bool OnInit() { return true; }
+ void OnExit() { UnregisterClasses(); }
+
+ // register the GL classes if not done yet, return true if ok, false if
+ // registration failed
+ static bool RegisterClasses();
+
+ // unregister the classes, done automatically on program termination
+ static void UnregisterClasses();
+
+private:
+ // wxGLCanvas is only used from the main thread so this is MT-ok
+ static bool ms_registeredGLClasses;
+
+ DECLARE_DYNAMIC_CLASS(wxGLModule)
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxGLModule, wxModule)
+
+bool wxGLModule::ms_registeredGLClasses = false;
+
+/* static */
+bool wxGLModule::RegisterClasses()
+{
+ if (ms_registeredGLClasses)
+ return true;
+
+ // We have to register a special window class because we need the CS_OWNDC
+ // style for GLCanvas.
+
+ /*
+ From Angel Popov <jumpo@bitex.com>
+
+ Here are two snips from a dicussion in the OpenGL Gamedev list that explains
+ how this problem can be fixed:
+
+ "There are 5 common DCs available in Win95. These are aquired when you call
+ GetDC or GetDCEx from a window that does _not_ have the OWNDC flag.
+ OWNDC flagged windows do not get their DC from the common DC pool, the issue
+ is they require 800 bytes each from the limited 64Kb local heap for GDI."
+
+ "The deal is, if you hold onto one of the 5 shared DC's too long (as GL apps
+ do), Win95 will actually "steal" it from you. MakeCurrent fails,
+ apparently, because Windows re-assigns the HDC to a different window. The
+ only way to prevent this, the only reliable means, is to set CS_OWNDC."
+ */
+
+ WNDCLASS wndclass;
+
+ // the fields which are common to all classes
+ wndclass.lpfnWndProc = (WNDPROC)wxWndProc;
+ wndclass.cbClsExtra = 0;
+ wndclass.cbWndExtra = sizeof( DWORD ); // VZ: what is this DWORD used for?
+ wndclass.hInstance = wxhInstance;
+ wndclass.hIcon = (HICON) NULL;
+ wndclass.hCursor = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
+ wndclass.lpszMenuName = NULL;
+
+ // Register the GLCanvas class name
+ wndclass.hbrBackground = (HBRUSH)NULL;
+ wndclass.lpszClassName = wxGLCanvasClassName;
+ wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_OWNDC;
+
+ if ( !::RegisterClass(&wndclass) )
+ {
+ wxLogLastError(wxT("RegisterClass(wxGLCanvasClass)"));
+ return false;
+ }
+
+ // Register the GLCanvas class name for windows which don't do full repaint
+ // on resize
+ wndclass.lpszClassName = wxGLCanvasClassNameNoRedraw;
+ wndclass.style &= ~(CS_HREDRAW | CS_VREDRAW);
+
+ if ( !::RegisterClass(&wndclass) )
+ {
+ wxLogLastError(wxT("RegisterClass(wxGLCanvasClassNameNoRedraw)"));
+
+ ::UnregisterClass(wxGLCanvasClassName, wxhInstance);
+
+ return false;
+ }
+
+ ms_registeredGLClasses = true;
+
+ return true;
+}
+
+/* static */
+void wxGLModule::UnregisterClasses()
+{
+ // we need to unregister the classes in case we're in a DLL which is
+ // unloaded and then loaded again because if we don't, the registration is
+ // going to fail in wxGLCanvas::Create() the next time we're loaded
+ if ( ms_registeredGLClasses )
+ {
+ ::UnregisterClass(wxGLCanvasClassName, wxhInstance);
+ ::UnregisterClass(wxGLCanvasClassNameNoRedraw, wxhInstance);
+
+ ms_registeredGLClasses = false;
+ }
+}
+
/*
* GLContext implementation
*/
-wxGLContext::wxGLContext(bool isRGB, wxGLCanvas *win, const wxPalette& palette)
+wxGLContext::wxGLContext(bool WXUNUSED(isRGB), wxGLCanvas *win, const wxPalette& WXUNUSED(palette))
{
m_window = win;
m_hDC = win->GetHDC();
m_glContext = wglCreateContext((HDC) m_hDC);
- wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGl context") );
+ wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGL context") );
wglMakeCurrent((HDC) m_hDC, m_glContext);
}
wxGLContext::wxGLContext(
- bool isRGB, wxGLCanvas *win,
- const wxPalette& palette,
- const wxGLContext *other /* for sharing display lists */
-)
+ bool WXUNUSED(isRGB), wxGLCanvas *win,
+ const wxPalette& WXUNUSED(palette),
+ const wxGLContext *other /* for sharing display lists */
+ )
{
- m_window = win;
+ m_window = win;
- m_hDC = win->GetHDC();
+ m_hDC = win->GetHDC();
- m_glContext = wglCreateContext((HDC) m_hDC);
- wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGl context") );
+ m_glContext = wglCreateContext((HDC) m_hDC);
+ wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGL context") );
- if( other != 0 )
- wglShareLists( other->m_glContext, m_glContext );
+ if( other != 0 )
+ wglShareLists( other->m_glContext, m_glContext );
- wglMakeCurrent((HDC) m_hDC, m_glContext);
+ wglMakeCurrent((HDC) m_hDC, m_glContext);
}
wxGLContext::~wxGLContext()
if (m_glContext)
{
wglMakeCurrent(NULL, NULL);
- wglDeleteContext(m_glContext);
+ wglDeleteContext(m_glContext);
}
}
wglMakeCurrent((HDC) m_hDC, m_glContext);
}
-/*
- setupPixelFormat(hDC);
- setupPalette(hDC);
-*/
+ /*
+ setupPixelFormat(hDC);
+ setupPalette(hDC);
+ */
}
-void wxGLContext::SetColour(const char *colour)
+void wxGLContext::SetColour(const wxChar *colour)
{
- float r = 0.0;
- float g = 0.0;
- float b = 0.0;
- wxColour *col = wxTheColourDatabase->FindColour(colour);
- if (col)
- {
- r = (float)(col->Red()/256.0);
- g = (float)(col->Green()/256.0);
- b = (float)(col->Blue()/256.0);
- glColor3f( r, g, b);
- }
+ wxColour col = wxTheColourDatabase->Find(colour);
+ if (col.Ok())
+ {
+ float r = (float)(col.Red()/256.0);
+ float g = (float)(col.Green()/256.0);
+ float b = (float)(col.Blue()/256.0);
+ glColor3f( r, g, b);
+ }
}
* wxGLCanvas implementation
*/
-IMPLEMENT_CLASS(wxGLCanvas, wxScrolledWindow)
+IMPLEMENT_CLASS(wxGLCanvas, wxWindow)
-BEGIN_EVENT_TABLE(wxGLCanvas, wxScrolledWindow)
+BEGIN_EVENT_TABLE(wxGLCanvas, wxWindow)
EVT_SIZE(wxGLCanvas::OnSize)
EVT_PALETTE_CHANGED(wxGLCanvas::OnPaletteChanged)
EVT_QUERY_NEW_PALETTE(wxGLCanvas::OnQueryNewPalette)
wxGLCanvas::wxGLCanvas(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size, long style, const wxString& name,
- int *attribList /* not used yet! */, const wxPalette& palette):
- wxScrolledWindow()
+ int *attribList, const wxPalette& palette) : wxWindow()
{
- m_glContext = (wxGLContext*) NULL;
+ m_glContext = (wxGLContext*) NULL;
- bool ret = Create(parent, id, pos, size, style, name);
+ bool ret = Create(parent, id, pos, size, style, name);
- if ( ret )
- {
- SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
- SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
- }
+ if ( ret )
+ {
+ SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
+ }
- m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
+ m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
- SetupPixelFormat();
- SetupPalette(palette);
+ SetupPixelFormat(attribList);
+ SetupPalette(palette);
- m_glContext = new wxGLContext(TRUE, this, palette);
+ m_glContext = new wxGLContext(true, this, palette);
}
wxGLCanvas::wxGLCanvas( wxWindow *parent,
const wxGLContext *shared, wxWindowID id,
const wxPoint& pos, const wxSize& size, long style, const wxString& name,
int *attribList, const wxPalette& palette )
- : wxScrolledWindow()
+ : wxWindow()
{
- m_glContext = (wxGLContext*) NULL;
+ m_glContext = (wxGLContext*) NULL;
- bool ret = Create(parent, id, pos, size, style, name);
+ bool ret = Create(parent, id, pos, size, style, name);
- if ( ret )
- {
- SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
- SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
- }
+ if ( ret )
+ {
+ SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
+ }
- m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
+ m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
- SetupPixelFormat();
- SetupPalette(palette);
+ SetupPixelFormat(attribList);
+ SetupPalette(palette);
- m_glContext = new wxGLContext(TRUE, this, palette, shared );
+ m_glContext = new wxGLContext(true, this, palette, shared );
}
// Not very useful for wxMSW, but this is to be wxGTK compliant
wxGLCanvas::wxGLCanvas( wxWindow *parent, const wxGLCanvas *shared, wxWindowID id,
const wxPoint& pos, const wxSize& size, long style, const wxString& name,
int *attribList, const wxPalette& palette ):
- wxScrolledWindow()
+ wxWindow()
{
- m_glContext = (wxGLContext*) NULL;
+ m_glContext = (wxGLContext*) NULL;
- bool ret = Create(parent, id, pos, size, style, name);
+ bool ret = Create(parent, id, pos, size, style, name);
- if ( ret )
- {
- SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
- SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
- }
+ if ( ret )
+ {
+ SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
+ }
- m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
+ m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
- SetupPixelFormat();
- SetupPalette(palette);
+ SetupPixelFormat(attribList);
+ SetupPalette(palette);
- wxGLContext *sharedContext=0;
- if (shared) sharedContext=shared->GetContext();
- m_glContext = new wxGLContext(TRUE, this, palette, sharedContext );
+ wxGLContext *sharedContext=0;
+ if (shared) sharedContext=shared->GetContext();
+ m_glContext = new wxGLContext(true, this, palette, sharedContext );
}
wxGLCanvas::~wxGLCanvas()
{
- if (m_glContext)
- delete m_glContext;
+ delete m_glContext;
::ReleaseDC((HWND) GetHWND(), (HDC) m_hDC);
}
-// Replaces wxWindow::Create functionality, since we need to use a different window class
-bool wxGLCanvas::Create(wxWindow *parent, wxWindowID id,
- const wxPoint& pos, const wxSize& size, long style, const wxString& name)
+// Replaces wxWindow::Create functionality, since we need to use a different
+// window class
+bool wxGLCanvas::Create(wxWindow *parent,
+ wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
-/* Suggestion from Kelly Brock <kbrock@8cs.com> (not yet implemented):
+ wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
-OpenGL corruption fix is simple assuming it doesn't screw anything else
-up. Add the following line to the top of the create function:
- wxSize parentSize = GetClientSize();
- All locations within the function that use 'size' are changed to
-'parentSize'.
- The above corrects the initial display corruption with the GeForce and
-TNT2, not sure about other NVidia cards yet.
-*/
-
- static bool registeredGLCanvasClass = FALSE;
-
- // We have to register a special window class because we need
- // the CS_OWNDC style for GLCanvas.
-
-/*
- From Angel Popov <jumpo@bitex.com>
-
- Here are two snips from a dicussion in the OpenGL Gamedev list that explains
- how this problem can be fixed:
-
- "There are 5 common DCs available in Win95. These are aquired when you call
- GetDC or GetDCEx from a window that does _not_ have the OWNDC flag.
- OWNDC flagged windows do not get their DC from the common DC pool, the issue
- is they require 800 bytes each from the limited 64Kb local heap for GDI."
-
- "The deal is, if you hold onto one of the 5 shared DC's too long (as GL apps
- do), Win95 will actually "steal" it from you. MakeCurrent fails,
- apparently, because Windows re-assigns the HDC to a different window. The
- only way to prevent this, the only reliable means, is to set CS_OWNDC."
-*/
-
- if (!registeredGLCanvasClass)
+ if ( !wxGLModule::RegisterClasses() )
{
- WNDCLASS wndclass;
-
- static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_OWNDC;
-
- // the fields which are common to all classes
- wndclass.lpfnWndProc = (WNDPROC)wxWndProc;
- wndclass.cbClsExtra = 0;
- wndclass.cbWndExtra = sizeof( DWORD ); // VZ: what is this DWORD used for?
- wndclass.hInstance = wxhInstance;
- wndclass.hIcon = (HICON) NULL;
- wndclass.hCursor = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
- wndclass.lpszMenuName = NULL;
-
- // Register the GLCanvas class name
- wndclass.hbrBackground = (HBRUSH)NULL;
- wndclass.lpszClassName = wxGLCanvasClassName;
- wndclass.style = styleNormal;
-
- if ( !RegisterClass(&wndclass) )
- {
- wxLogLastError(wxT("RegisterClass(wxGLCanvasClass)"));
-
- return FALSE;
- }
- registeredGLCanvasClass = TRUE;
- }
+ wxLogError(_("Failed to register OpenGL window class."));
- wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindow without parent") );
+ return false;
+ }
if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
- return FALSE;
+ return false;
parent->AddChild(this);
DWORD msflags = 0;
- if ( style & wxBORDER )
- msflags |= WS_BORDER;
- if ( style & wxTHICK_FRAME )
- msflags |= WS_THICKFRAME;
-/*
- A general rule with OpenGL and Win32 is that any window that will have a
- HGLRC built for it must have two flags: WS_CLIPCHILDREN & WS_CLIPSIBLINGS.
- You can find references about this within the knowledge base and most OpenGL
- books that contain the wgl function descriptions.
-*/
+ /*
+ A general rule with OpenGL and Win32 is that any window that will have a
+ HGLRC built for it must have two flags: WS_CLIPCHILDREN & WS_CLIPSIBLINGS.
+ You can find references about this within the knowledge base and most OpenGL
+ books that contain the wgl function descriptions.
+ */
- msflags |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS;
-// if ( style & wxCLIP_CHILDREN )
-// msflags |= WS_CLIPCHILDREN;
- msflags |= WS_CLIPCHILDREN;
+ WXDWORD exStyle = 0;
+ msflags |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
+ msflags |= MSWGetStyle(style, & exStyle) ;
- bool want3D;
- WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D);
+ return MSWCreate(wxGLCanvasClassName, NULL, pos, size, msflags, exStyle);
+}
- // Even with extended styles, need to combine with WS_BORDER
- // for them to look right.
- if ( want3D || (m_windowStyle & wxSIMPLE_BORDER) || (m_windowStyle & wxRAISED_BORDER ) ||
- (m_windowStyle & wxSUNKEN_BORDER) || (m_windowStyle & wxDOUBLE_BORDER))
- {
- msflags |= WS_BORDER;
- }
+static void AdjustPFDForAttributes(PIXELFORMATDESCRIPTOR& pfd, int *attribList)
+{
+ if (attribList) {
+ pfd.dwFlags &= ~PFD_DOUBLEBUFFER;
+ pfd.iPixelType = PFD_TYPE_COLORINDEX;
+ pfd.cColorBits = 0;
+ int arg=0;
- // calculate the value to return from WM_GETDLGCODE handler
- if ( GetWindowStyleFlag() & wxWANTS_CHARS )
+ while( (attribList[arg]!=0) )
{
- // want everything: i.e. all keys and WM_CHAR message
- m_lDlgCode = DLGC_WANTARROWS | DLGC_WANTCHARS |
- DLGC_WANTTAB | DLGC_WANTMESSAGE;
+ switch( attribList[arg++] )
+ {
+ case WX_GL_RGBA:
+ pfd.iPixelType = PFD_TYPE_RGBA;
+ break;
+ case WX_GL_BUFFER_SIZE:
+ pfd.cColorBits = (BYTE)attribList[arg++];
+ break;
+ case WX_GL_LEVEL:
+ // this member looks like it may be obsolete
+ if (attribList[arg] > 0) {
+ pfd.iLayerType = (BYTE)PFD_OVERLAY_PLANE;
+ } else if (attribList[arg] < 0) {
+ pfd.iLayerType = (BYTE)PFD_UNDERLAY_PLANE;
+ } else {
+ pfd.iLayerType = (BYTE)PFD_MAIN_PLANE;
+ }
+ arg++;
+ break;
+ case WX_GL_DOUBLEBUFFER:
+ pfd.dwFlags |= PFD_DOUBLEBUFFER;
+ break;
+ case WX_GL_STEREO:
+ pfd.dwFlags |= PFD_STEREO;
+ break;
+ case WX_GL_AUX_BUFFERS:
+ pfd.cAuxBuffers = (BYTE)attribList[arg++];
+ break;
+ case WX_GL_MIN_RED:
+ pfd.cColorBits = (BYTE)(pfd.cColorBits + (pfd.cRedBits = (BYTE)attribList[arg++]));
+ break;
+ case WX_GL_MIN_GREEN:
+ pfd.cColorBits = (BYTE)(pfd.cColorBits + (pfd.cGreenBits = (BYTE)attribList[arg++]));
+ break;
+ case WX_GL_MIN_BLUE:
+ pfd.cColorBits = (BYTE)(pfd.cColorBits + (pfd.cBlueBits = (BYTE)attribList[arg++]));
+ break;
+ case WX_GL_MIN_ALPHA:
+ // doesn't count in cColorBits
+ pfd.cAlphaBits = (BYTE)attribList[arg++];
+ break;
+ case WX_GL_DEPTH_SIZE:
+ pfd.cDepthBits = (BYTE)attribList[arg++];
+ break;
+ case WX_GL_STENCIL_SIZE:
+ pfd.cStencilBits = (BYTE)attribList[arg++];
+ break;
+ case WX_GL_MIN_ACCUM_RED:
+ pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumRedBits = (BYTE)attribList[arg++]));
+ break;
+ case WX_GL_MIN_ACCUM_GREEN:
+ pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumGreenBits = (BYTE)attribList[arg++]));
+ break;
+ case WX_GL_MIN_ACCUM_BLUE:
+ pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumBlueBits = (BYTE)attribList[arg++]));
+ break;
+ case WX_GL_MIN_ACCUM_ALPHA:
+ pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumAlphaBits = (BYTE)attribList[arg++]));
+ break;
+ default:
+ break;
+ }
}
+ }
+}
- MSWCreate(m_windowId, parent, wxGLCanvasClassName, this, NULL,
- pos.x, pos.y,
- WidthDefault(size.x), HeightDefault(size.y),
- msflags, NULL, exStyle);
-
- return TRUE;
-
-}
-
-void wxGLCanvas::SetupPixelFormat() // (HDC hDC)
-{
- PIXELFORMATDESCRIPTOR pfd = {
- sizeof(PIXELFORMATDESCRIPTOR), /* size */
- 1, /* version */
- PFD_SUPPORT_OPENGL |
- PFD_DRAW_TO_WINDOW |
- PFD_DOUBLEBUFFER, /* support double-buffering */
- PFD_TYPE_RGBA, /* color type */
- 16, /* prefered color depth */
- 0, 0, 0, 0, 0, 0, /* color bits (ignored) */
- 0, /* no alpha buffer */
- 0, /* alpha bits (ignored) */
- 0, /* no accumulation buffer */
- 0, 0, 0, 0, /* accum bits (ignored) */
- 16, /* depth buffer */
- 0, /* no stencil buffer */
- 0, /* no auxiliary buffers */
- PFD_MAIN_PLANE, /* main layer */
- 0, /* reserved */
- 0, 0, 0, /* no layer, visible, damage masks */
+void wxGLCanvas::SetupPixelFormat(int *attribList) // (HDC hDC)
+{
+ PIXELFORMATDESCRIPTOR pfd = {
+ sizeof(PIXELFORMATDESCRIPTOR), /* size */
+ 1, /* version */
+ PFD_SUPPORT_OPENGL |
+ PFD_DRAW_TO_WINDOW |
+ PFD_DOUBLEBUFFER, /* support double-buffering */
+ PFD_TYPE_RGBA, /* color type */
+ 16, /* prefered color depth */
+ 0, 0, 0, 0, 0, 0, /* color bits (ignored) */
+ 0, /* no alpha buffer */
+ 0, /* alpha bits (ignored) */
+ 0, /* no accumulation buffer */
+ 0, 0, 0, 0, /* accum bits (ignored) */
+ 16, /* depth buffer */
+ 0, /* no stencil buffer */
+ 0, /* no auxiliary buffers */
+ PFD_MAIN_PLANE, /* main layer */
+ 0, /* reserved */
+ 0, 0, 0, /* no layer, visible, damage masks */
};
- int pixelFormat;
- pixelFormat = ChoosePixelFormat((HDC) m_hDC, &pfd);
- if (pixelFormat == 0) {
- MessageBox(WindowFromDC((HDC) m_hDC), wxT("ChoosePixelFormat failed."), wxT("Error"),
- MB_ICONERROR | MB_OK);
- exit(1);
- }
+ AdjustPFDForAttributes(pfd, attribList);
- if (SetPixelFormat((HDC) m_hDC, pixelFormat, &pfd) != TRUE) {
- MessageBox(WindowFromDC((HDC) m_hDC), wxT("SetPixelFormat failed."), wxT("Error"),
- MB_ICONERROR | MB_OK);
- exit(1);
+ int pixelFormat = ChoosePixelFormat((HDC) m_hDC, &pfd);
+ if (pixelFormat == 0) {
+ wxLogLastError(_T("ChoosePixelFormat"));
+ }
+ else {
+ if ( !::SetPixelFormat((HDC) m_hDC, pixelFormat, &pfd) ) {
+ wxLogLastError(_T("SetPixelFormat"));
}
+ }
}
void wxGLCanvas::SetupPalette(const wxPalette& palette)
}
else
{
- return;
+ return;
}
m_palette = palette;
if (m_palette.Ok())
{
- SelectPalette((HDC) m_hDC, (HPALETTE) m_palette.GetHPALETTE(), FALSE);
- RealizePalette((HDC) m_hDC);
+ ::SelectPalette((HDC) m_hDC, (HPALETTE) m_palette.GetHPALETTE(), FALSE);
+ ::RealizePalette((HDC) m_hDC);
}
}
DescribePixelFormat((HDC) m_hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
- paletteSize = 1 << pfd.cColorBits;
+ paletteSize = 1 << pfd.cColorBits;
LOGPALETTE* pPal =
(LOGPALETTE*) malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
pPal->palVersion = 0x300;
- pPal->palNumEntries = paletteSize;
+ pPal->palNumEntries = (WORD)paletteSize;
/* build a simple RGB color palette */
{
- int redMask = (1 << pfd.cRedBits) - 1;
- int greenMask = (1 << pfd.cGreenBits) - 1;
- int blueMask = (1 << pfd.cBlueBits) - 1;
- int i;
-
-
for (i=0; i<paletteSize; ++i) {
- pPal->palPalEntry[i].peRed =
- (((i >> pfd.cRedShift) & redMask) * 255) / redMask;
- pPal->palPalEntry[i].peGreen =
- (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
- pPal->palPalEntry[i].peBlue =
- (((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
- pPal->palPalEntry[i].peFlags = 0;
- }
+ int redMask = (1 << pfd.cRedBits) - 1;
+ int greenMask = (1 << pfd.cGreenBits) - 1;
+ int blueMask = (1 << pfd.cBlueBits) - 1;
+ int i;
+
+ for (i=0; i<paletteSize; ++i) {
+ pPal->palPalEntry[i].peRed =
+ (BYTE)((((i >> pfd.cRedShift) & redMask) * 255) / redMask);
+ pPal->palPalEntry[i].peGreen =
+ (BYTE)((((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask);
+ pPal->palPalEntry[i].peBlue =
+ (BYTE)((((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask);
+ pPal->palPalEntry[i].peFlags = 0;
+ }
}
HPALETTE hPalette = CreatePalette(pPal);
m_glContext->SwapBuffers();
}
-void wxGLCanvas::OnSize(wxSizeEvent& event)
+void wxGLCanvas::OnSize(wxSizeEvent& WXUNUSED(event))
{
- int width, height;
- GetClientSize(& width, & height);
-
- if (m_glContext)
- {
- m_glContext->SetCurrent();
-
- glViewport(0, 0, (GLint)width, (GLint)height);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 );
- glMatrixMode(GL_MODELVIEW);
- }
}
void wxGLCanvas::SetCurrent()
}
}
-void wxGLCanvas::SetColour(const char *colour)
+void wxGLCanvas::SetColour(const wxChar *colour)
{
if (m_glContext)
m_glContext->SetColour(colour);
// So we need wxFrame to call OnQueryNewPalette for all children...
void wxGLCanvas::OnQueryNewPalette(wxQueryNewPaletteEvent& event)
{
- /* realize palette if this is the current window */
- if ( GetPalette()->Ok() ) {
- ::UnrealizeObject((HPALETTE) GetPalette()->GetHPALETTE());
- ::SelectPalette((HDC) GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
- ::RealizePalette((HDC) GetHDC());
- Refresh();
- event.SetPaletteRealized(TRUE);
- }
- else
- event.SetPaletteRealized(FALSE);
+ /* realize palette if this is the current window */
+ if ( GetPalette()->Ok() ) {
+ ::UnrealizeObject((HPALETTE) GetPalette()->GetHPALETTE());
+ ::SelectPalette((HDC) GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
+ ::RealizePalette((HDC) GetHDC());
+ Refresh();
+ event.SetPaletteRealized(true);
+ }
+ else
+ event.SetPaletteRealized(false);
}
// I think this doesn't have to be propagated to child windows.
void wxGLCanvas::OnPaletteChanged(wxPaletteChangedEvent& event)
{
- /* realize palette if this is *not* the current window */
- if ( GetPalette() &&
+ /* realize palette if this is *not* the current window */
+ if ( GetPalette() &&
GetPalette()->Ok() && (this != event.GetChangedWindow()) )
- {
- ::UnrealizeObject((HPALETTE) GetPalette()->GetHPALETTE());
- ::SelectPalette((HDC) GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
- ::RealizePalette((HDC) GetHDC());
- Refresh();
- }
+ {
+ ::UnrealizeObject((HPALETTE) GetPalette()->GetHPALETTE());
+ ::SelectPalette((HDC) GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
+ ::RealizePalette((HDC) GetHDC());
+ Refresh();
+ }
}
/* Give extensions proper function names. */
/* EXT_vertex_array */
-void glArrayElementEXT(GLint i)
+void glArrayElementEXT(GLint WXUNUSED(i))
{
}
-void glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glColorPointerEXT(GLint WXUNUSED(size), GLenum WXUNUSED(type), GLsizei WXUNUSED(stride), GLsizei WXUNUSED(count), const GLvoid *WXUNUSED(pointer))
{
}
-void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count)
+void glDrawArraysEXT(GLenum WXUNUSED_WITHOUT_GL_EXT_vertex_array(mode),
+ GLint WXUNUSED_WITHOUT_GL_EXT_vertex_array(first),
+ GLsizei WXUNUSED_WITHOUT_GL_EXT_vertex_array(count))
{
#ifdef GL_EXT_vertex_array
static PFNGLDRAWARRAYSEXTPROC proc = 0;
#endif
}
-void glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer)
+void glEdgeFlagPointerEXT(GLsizei WXUNUSED(stride), GLsizei WXUNUSED(count), const GLboolean *WXUNUSED(pointer))
{
}
-void glGetPointervEXT(GLenum pname, GLvoid* *params)
+void glGetPointervEXT(GLenum WXUNUSED(pname), GLvoid* *WXUNUSED(params))
{
}
-void glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glIndexPointerEXT(GLenum WXUNUSED(type), GLsizei WXUNUSED(stride), GLsizei WXUNUSED(count), const GLvoid *WXUNUSED(pointer))
{
}
-void glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glNormalPointerEXT(GLenum WXUNUSED_WITHOUT_GL_EXT_vertex_array(type),
+ GLsizei WXUNUSED_WITHOUT_GL_EXT_vertex_array(stride),
+ GLsizei WXUNUSED_WITHOUT_GL_EXT_vertex_array(count),
+ const GLvoid *WXUNUSED_WITHOUT_GL_EXT_vertex_array(pointer))
{
#ifdef GL_EXT_vertex_array
- static PFNGLNORMALPOINTEREXTPROC proc = 0;
+ static PFNGLNORMALPOINTEREXTPROC proc = 0;
- if ( !proc )
- {
- proc = (PFNGLNORMALPOINTEREXTPROC) wglGetProcAddress("glNormalPointerEXT");
- }
+ if ( !proc )
+ {
+ proc = (PFNGLNORMALPOINTEREXTPROC) wglGetProcAddress("glNormalPointerEXT");
+ }
- if ( proc )
- (* proc) (type, stride, count, pointer);
+ if ( proc )
+ (* proc) (type, stride, count, pointer);
#endif
}
-void glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glTexCoordPointerEXT(GLint WXUNUSED(size), GLenum WXUNUSED(type), GLsizei WXUNUSED(stride), GLsizei WXUNUSED(count), const GLvoid *WXUNUSED(pointer))
{
}
-void glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glVertexPointerEXT(GLint WXUNUSED_WITHOUT_GL_EXT_vertex_array(size),
+ GLenum WXUNUSED_WITHOUT_GL_EXT_vertex_array(type),
+ GLsizei WXUNUSED_WITHOUT_GL_EXT_vertex_array(stride),
+ GLsizei WXUNUSED_WITHOUT_GL_EXT_vertex_array(count),
+ const GLvoid *WXUNUSED_WITHOUT_GL_EXT_vertex_array(pointer))
{
#ifdef GL_EXT_vertex_array
- static PFNGLVERTEXPOINTEREXTPROC proc = 0;
-
- if ( !proc )
- {
- proc = (PFNGLVERTEXPOINTEREXTPROC) wglGetProcAddress("glVertexPointerEXT");
- }
+ static PFNGLVERTEXPOINTEREXTPROC proc = 0;
- if ( proc )
- (* proc) (size, type, stride, count, pointer);
+ if ( !proc )
+ {
+ proc = (PFNGLVERTEXPOINTEREXTPROC) wglGetProcAddress("glVertexPointerEXT");
+ }
+ if ( proc )
+ (* proc) (size, type, stride, count, pointer);
#endif
}
/* EXT_color_subtable */
-void glColorSubtableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *table)
+void glColorSubtableEXT(GLenum WXUNUSED(target), GLsizei WXUNUSED(start), GLsizei WXUNUSED(count), GLenum WXUNUSED(format), GLenum WXUNUSED(type), const GLvoid *WXUNUSED(table))
{
}
/* EXT_color_table */
-void glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
+void glColorTableEXT(GLenum WXUNUSED(target), GLenum WXUNUSED(internalformat), GLsizei WXUNUSED(width), GLenum WXUNUSED(format), GLenum WXUNUSED(type), const GLvoid *WXUNUSED(table))
{
}
-void glCopyColorTableEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+void glCopyColorTableEXT(GLenum WXUNUSED(target), GLenum WXUNUSED(internalformat), GLint WXUNUSED(x), GLint WXUNUSED(y), GLsizei WXUNUSED(width))
{
}
-void glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table)
+void glGetColorTableEXT(GLenum WXUNUSED(target), GLenum WXUNUSED(format), GLenum WXUNUSED(type), GLvoid *WXUNUSED(table))
{
}
-void glGetColorTableParamaterfvEXT(GLenum target, GLenum pname, GLfloat *params)
+void glGetColorTableParamaterfvEXT(GLenum WXUNUSED(target), GLenum WXUNUSED(pname), GLfloat *WXUNUSED(params))
{
}
-void glGetColorTavleParameterivEXT(GLenum target, GLenum pname, GLint *params)
+void glGetColorTavleParameterivEXT(GLenum WXUNUSED(target), GLenum WXUNUSED(pname), GLint *WXUNUSED(params))
{
}
/* SGI_compiled_vertex_array */
-void glLockArraysSGI(GLint first, GLsizei count)
+void glLockArraysSGI(GLint WXUNUSED(first), GLsizei WXUNUSED(count))
{
}
/* SGI_cull_vertex */
-void glCullParameterdvSGI(GLenum pname, GLdouble* params)
+void glCullParameterdvSGI(GLenum WXUNUSED(pname), GLdouble* WXUNUSED(params))
{
}
-void glCullParameterfvSGI(GLenum pname, GLfloat* params)
+void glCullParameterfvSGI(GLenum WXUNUSED(pname), GLfloat* WXUNUSED(params))
{
}
/* SGI_index_func */
-void glIndexFuncSGI(GLenum func, GLclampf ref)
+void glIndexFuncSGI(GLenum WXUNUSED(func), GLclampf WXUNUSED(ref))
{
}
/* SGI_index_material */
-void glIndexMaterialSGI(GLenum face, GLenum mode)
+void glIndexMaterialSGI(GLenum WXUNUSED(face), GLenum WXUNUSED(mode))
{
}
/* WIN_swap_hint */
-void glAddSwapHintRectWin(GLint x, GLint y, GLsizei width, GLsizei height)
+void glAddSwapHintRectWin(GLint WXUNUSED(x), GLint WXUNUSED(y), GLsizei WXUNUSED(width), GLsizei WXUNUSED(height))
+{
+}
+
+
+//---------------------------------------------------------------------------
+// wxGLApp
+//---------------------------------------------------------------------------
+
+IMPLEMENT_CLASS(wxGLApp, wxApp)
+
+bool wxGLApp::InitGLVisual(int *attribList)
+{
+ int pixelFormat;
+ PIXELFORMATDESCRIPTOR pfd = {
+ sizeof(PIXELFORMATDESCRIPTOR), /* size */
+ 1, /* version */
+ PFD_SUPPORT_OPENGL |
+ PFD_DRAW_TO_WINDOW |
+ PFD_DOUBLEBUFFER, /* support double-buffering */
+ PFD_TYPE_RGBA, /* color type */
+ 16, /* prefered color depth */
+ 0, 0, 0, 0, 0, 0, /* color bits (ignored) */
+ 0, /* no alpha buffer */
+ 0, /* alpha bits (ignored) */
+ 0, /* no accumulation buffer */
+ 0, 0, 0, 0, /* accum bits (ignored) */
+ 16, /* depth buffer */
+ 0, /* no stencil buffer */
+ 0, /* no auxiliary buffers */
+ PFD_MAIN_PLANE, /* main layer */
+ 0, /* reserved */
+ 0, 0, 0, /* no layer, visible, damage masks */
+ };
+
+ AdjustPFDForAttributes(pfd, attribList);
+
+ // use DC for whole (root) screen, since no windows have yet been created
+ pixelFormat = ChoosePixelFormat(ScreenHDC(), &pfd);
+
+ if (pixelFormat == 0) {
+ wxLogError(_("Failed to initialize OpenGL"));
+ return false;
+ }
+
+ return true;
+}
+
+wxGLApp::~wxGLApp()
{
}
projects / wxWidgets.git / blobdiff