Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1. switched to new wxGLCanvas API (not using the implicit context)

Browse Source 
2. pruned everything not related to OpenGL, making the remaining code much
   more readable
3. show using the same wxGLContext with multiple wxGLCanvases


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@45369 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2007-04-09 22:54:40 +00:00
parent bbe645133b
commit 43c742d005
2 changed files with 169 additions and 452 deletions
Download Patch File Download Diff File Expand all files Collapse all files

553
samples/opengl/cube/cube.cpp
View File

@@ -1,13 +1,21 @@
/////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Name: cube.cpp
// Purpose: wxGLCanvas demo program
// Author: Julian Smart
// Modified by:
// Modified by: Vadim Zeitlin to use new wxGLCanvas API (2007-04-09)
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
@@ -25,210 +33,124 @@
#endif
#include "cube.h"
#if !defined(__WXMSW__) && !defined(__WXPM__)
#include "../../sample.xpm"
#ifndef __WXMSW__ // for StopWatch, see remark below
#if defined(__WXMAC__) && !defined(__DARWIN__)
#include <utime.h>
#include <unistd.h>
#else
#include <sys/time.h>
#include <sys/unistd.h>
#endif
#else
#include <sys/timeb.h>
#endif
#define ID_NEW_WINDOW 10000
#define ID_DEF_ROTATE_LEFT_KEY 10001
#define ID_DEF_ROTATE_RIGHT_KEY 10002
// ============================================================================
// implementation
// ============================================================================
/*----------------------------------------------------------
Control to get a keycode
----------------------------------------------------------*/
class ScanCodeCtrl : public wxTextCtrl
{
public:
ScanCodeCtrl( wxWindow* parent, wxWindowID id, int code,
const wxPoint& pos, const wxSize& size );
// ----------------------------------------------------------------------------
// MyApp: the application object
// ----------------------------------------------------------------------------
void OnChar( wxKeyEvent& WXUNUSED(event) )
IMPLEMENT_APP(MyApp)
bool MyApp::OnInit()
{
// Do nothing
if ( !wxApp::OnInit() )
return false;
// Create the main window
new MyFrame();
return true;
}
void OnKeyDown(wxKeyEvent& event);
private:
// Any class wishing to process wxWidgets events must use this macro
DECLARE_EVENT_TABLE()
};
BEGIN_EVENT_TABLE( ScanCodeCtrl, wxTextCtrl )
EVT_CHAR( ScanCodeCtrl::OnChar )
EVT_KEY_DOWN( ScanCodeCtrl::OnKeyDown )
END_EVENT_TABLE()
ScanCodeCtrl::ScanCodeCtrl( wxWindow* parent, wxWindowID id, int code,
const wxPoint& pos, const wxSize& size )
: wxTextCtrl( parent, id, wxEmptyString, pos, size )
int MyApp::OnExit()
{
SetValue( wxString::Format(wxT("0x%04x"), code) );
delete m_glContext;
return wxApp::OnExit();
}
void ScanCodeCtrl::OnKeyDown( wxKeyEvent& event )
void MyApp::SetCurrent(wxGLCanvas *canvas)
{
SetValue( wxString::Format(wxT("0x%04x"), event.GetKeyCode()) );
wxCHECK_RET( canvas, _T("canvas can't be NULL") );
if ( !m_glContext )
m_glContext = new wxGLContext(canvas);
m_glContext->SetCurrent(*canvas);
}
/*------------------------------------------------------------------
Dialog for defining a keypress
-------------------------------------------------------------------*/
class ScanCodeDialog : public wxDialog
{
public:
ScanCodeDialog( wxWindow* parent, wxWindowID id, const int code,
const wxString &descr, const wxString& title );
int GetValue();
private:
ScanCodeCtrl *m_ScanCode;
wxTextCtrl *m_Description;
};
ScanCodeDialog::ScanCodeDialog( wxWindow* parent, wxWindowID id,
const int code, const wxString &descr, const wxString& title )
: wxDialog( parent, id, title, wxDefaultPosition, wxSize(96*2,76*2) )
{
new wxStaticText( this, wxID_ANY, _T("Scancode"), wxPoint(4*2,3*2),
wxSize(31*2,12*2) );
m_ScanCode = new ScanCodeCtrl( this, wxID_ANY, code, wxPoint(37*2,6*2),
wxSize(53*2,14*2) );
new wxStaticText( this, wxID_ANY, _T("Description"), wxPoint(4*2,24*2),
wxSize(32*2,12*2) );
m_Description = new wxTextCtrl( this, wxID_ANY, descr, wxPoint(37*2,27*2),
wxSize(53*2,14*2) );
new wxButton( this, wxID_OK, _T("Ok"), wxPoint(20*2,50*2), wxSize(20*2,13*2) );
new wxButton( this, wxID_CANCEL, _T("Cancel"), wxPoint(44*2,50*2),
wxSize(25*2,13*2) );
}
int ScanCodeDialog::GetValue()
{
int code;
wxString buf = m_ScanCode->GetValue();
wxSscanf( buf.c_str(), _T("%i"), &code );
return code;
}
/*----------------------------------------------------------------------
Utility function to get the elapsed time (in msec) since a given point
in time (in sec) (because current version of wxGetElapsedTime doesn<73>t
works right with glibc-2.1 and linux, at least for me)
-----------------------------------------------------------------------*/
unsigned long StopWatch( unsigned long *sec_base )
{
unsigned long secs,msec;
#if defined(__WXMSW__)
struct timeb tb;
ftime( &tb );
secs = tb.time;
msec = tb.millitm;
#elif defined(__WXMAC__) && !defined(__DARWIN__)
wxLongLong tl = wxGetLocalTimeMillis();
secs = (unsigned long) (tl.GetValue() / 1000);
msec = (unsigned long) (tl.GetValue() - secs*1000);
#else
// think every unice has gettimeofday
struct timeval tv;
gettimeofday( &tv, (struct timezone *)NULL );
secs = tv.tv_sec;
msec = tv.tv_usec/1000;
#endif
if( *sec_base == 0 )
*sec_base = secs;
return( (secs-*sec_base)*1000 + msec );
}
/*----------------------------------------------------------------
Implementation of Test-GLCanvas
-----------------------------------------------------------------*/
// ----------------------------------------------------------------------------
// TestGLCanvas
// ----------------------------------------------------------------------------
BEGIN_EVENT_TABLE(TestGLCanvas, wxGLCanvas)
EVT_SIZE(TestGLCanvas::OnSize)
EVT_PAINT(TestGLCanvas::OnPaint)
EVT_ERASE_BACKGROUND(TestGLCanvas::OnEraseBackground)
EVT_KEY_DOWN(TestGLCanvas::OnKeyDown)
EVT_KEY_UP( TestGLCanvas::OnKeyUp )
EVT_ENTER_WINDOW( TestGLCanvas::OnEnterWindow )
END_EVENT_TABLE()
unsigned long TestGLCanvas::m_secbase = 0;
int TestGLCanvas::m_TimeInitialized = 0;
unsigned long TestGLCanvas::m_xsynct;
unsigned long TestGLCanvas::m_gsynct;
static /* const */ int attribs[] = { WX_GL_RGBA, WX_GL_DOUBLEBUFFER, 0 };
TestGLCanvas::TestGLCanvas(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size, long style, const wxString& name)
: wxGLCanvas(parent, (wxGLCanvas*) NULL, id, pos, size, style|wxFULL_REPAINT_ON_RESIZE , name )
{
m_init = false;
m_gllist = 0;
m_rleft = WXK_LEFT;
m_rright = WXK_RIGHT;
}
TestGLCanvas::TestGLCanvas(wxWindow *parent, const TestGLCanvas *other,
wxWindowID id, const wxPoint& pos, const wxSize& size, long style,
const wxString& name )
: wxGLCanvas(parent, other->GetContext(), id, pos, size, style|wxFULL_REPAINT_ON_RESIZE , name)
{
m_init = false;
m_gllist = other->m_gllist; // share display list
m_rleft = WXK_LEFT;
m_rright = WXK_RIGHT;
}
TestGLCanvas::~TestGLCanvas()
TestGLCanvas::TestGLCanvas(wxWindow *parent)
: wxGLCanvas(parent, wxID_ANY, attribs)
{
InitGL();
}
// this function is called on each repaint so it should be fast
void TestGLCanvas::Render()
{
wxGetApp().SetCurrent(this);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glCallList(m_gllist);
glFlush();
SwapBuffers();
}
void TestGLCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
{
wxPaintDC dc(this);
#ifndef __WXMOTIF__
if (!GetContext()) return;
#endif
SetCurrent();
// Init OpenGL once, but after SetCurrent
if (!m_init)
{
InitGL();
m_init = true;
Render();
}
void TestGLCanvas::OnSize(wxSizeEvent& WXUNUSED(event))
{
// set GL viewport (not called by wxGLCanvas::OnSize on all platforms...)
int w, h;
GetClientSize(&w, &h);
wxGetApp().SetCurrent(this);
glViewport(0, 0, w, h);
}
void TestGLCanvas::InitGL()
{
wxGetApp().SetCurrent(this);
/* set viewing projection */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-0.5f, 0.5f, -0.5f, 0.5f, 1.0f, 3.0f);
/* position viewer */
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -2.0f);
/* clear color and depth buffers */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* position object */
glRotatef(30.0f, 1.0f, 0.0f, 0.0f);
glRotatef(30.0f, 0.0f, 1.0f, 0.0f);
if( m_gllist == 0 )
{
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// create the list of commands to draw the cube: then we can just (quickly)
// execute it in Render() later
m_gllist = glGenLists(1);
glNewList( m_gllist, GL_COMPILE_AND_EXECUTE );
glNewList(m_gllist, GL_COMPILE);
/* draw six faces of a cube */
glBegin(GL_QUADS);
glNormal3f( 0.0f, 0.0f, 1.0f);
@@ -258,274 +180,95 @@ void TestGLCanvas::Render()
glEndList();
}
else
{
glCallList(m_gllist);
}
glFlush();
SwapBuffers();
}
void TestGLCanvas::OnEnterWindow( wxMouseEvent& WXUNUSED(event) )
{
SetFocus();
}
void TestGLCanvas::OnPaint( wxPaintEvent& WXUNUSED(event) )
{
Render();
}
void TestGLCanvas::OnSize(wxSizeEvent& event)
{
// this is also necessary to update the context on some platforms
wxGLCanvas::OnSize(event);
// set GL viewport (not called by wxGLCanvas::OnSize on all platforms...)
int w, h;
GetClientSize(&w, &h);
#ifndef __WXMOTIF__
if (GetContext())
#endif
{
SetCurrent();
glViewport(0, 0, (GLint) w, (GLint) h);
}
}
void TestGLCanvas::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
{
// Do nothing, to avoid flashing.
}
void TestGLCanvas::InitGL()
{
SetCurrent();
/* set viewing projection */
glMatrixMode(GL_PROJECTION);
glFrustum(-0.5f, 0.5f, -0.5f, 0.5f, 1.0f, 3.0f);
/* position viewer */
glMatrixMode(GL_MODELVIEW);
glTranslatef(0.0f, 0.0f, -2.0f);
/* position object */
glRotatef(30.0f, 1.0f, 0.0f, 0.0f);
glRotatef(30.0f, 0.0f, 1.0f, 0.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
}
GLfloat TestGLCanvas::CalcRotateSpeed( unsigned long acceltime )
{
GLfloat t,v;
t = ((GLfloat)acceltime) / 1000.0f;
if( t < 0.5f )
v = t;
else if( t < 1.0f )
v = t * (2.0f - t);
else
v = 0.75f;
return(v);
}
GLfloat TestGLCanvas::CalcRotateAngle( unsigned long lasttime,
unsigned long acceltime )
{
GLfloat t,s1,s2;
t = ((GLfloat)(acceltime - lasttime)) / 1000.0f;
s1 = CalcRotateSpeed( lasttime );
s2 = CalcRotateSpeed( acceltime );
return( t * (s1 + s2) * 135.0f );
}
void TestGLCanvas::Action( long code, unsigned long lasttime,
unsigned long acceltime )
{
GLfloat angle = CalcRotateAngle( lasttime, acceltime );
if (code == m_rleft)
Rotate( angle );
else if (code == m_rright)
Rotate( -angle );
}
void TestGLCanvas::OnKeyDown( wxKeyEvent& event )
{
long evkey = event.GetKeyCode();
if (evkey == 0) return;
GLfloat x = 0,
y = 0,
z = 0;
if (!m_TimeInitialized)
bool inverse = false;
switch ( event.GetKeyCode() )
{
m_TimeInitialized = 1;
m_xsynct = event.GetTimestamp();
m_gsynct = StopWatch(&m_secbase);
case WXK_RIGHT:
inverse = true;
// fall through
m_Key = evkey;
m_StartTime = 0;
m_LastTime = 0;
m_LastRedraw = 0;
}
case WXK_LEFT:
// rotate around Z axis
z = 1;
break;
unsigned long currTime = event.GetTimestamp() - m_xsynct;
case WXK_DOWN:
inverse = true;
// fall through
if (evkey != m_Key)
{
m_Key = evkey;
m_LastRedraw = m_StartTime = m_LastTime = currTime;
}
if (currTime >= m_LastRedraw) // Redraw:
{
Action( m_Key, m_LastTime-m_StartTime, currTime-m_StartTime );
#if defined(__WXMAC__) && !defined(__DARWIN__)
m_LastRedraw = currTime; // StopWatch() doesn't work on Mac...
#else
m_LastRedraw = StopWatch(&m_secbase) - m_gsynct;
#endif
m_LastTime = currTime;
}
case WXK_UP:
// rotate around Y axis
y = 1;
break;
default:
event.Skip();
return;
}
void TestGLCanvas::OnKeyUp( wxKeyEvent& event )
{
m_Key = 0;
m_StartTime = 0;
m_LastTime = 0;
m_LastRedraw = 0;
float angle = 5;
if ( inverse )
angle = -angle;
event.Skip();
}
void TestGLCanvas::Rotate( GLfloat deg )
{
SetCurrent();
wxGetApp().SetCurrent(this);
glMatrixMode(GL_MODELVIEW);
glRotatef((GLfloat)deg, 0.0f, 0.0f, 1.0f);
Refresh(false);
glRotatef(angle, x, y, z);
// refresh all cubes
for ( wxWindowList::const_iterator i = wxTopLevelWindows.begin();
i != wxTopLevelWindows.end();
++i )
{
(*i)->Refresh(false);
}
}
/* -----------------------------------------------------------------------
Main Window
-------------------------------------------------------------------------*/
// ----------------------------------------------------------------------------
// MyFrame: main application window
// ----------------------------------------------------------------------------
BEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_MENU(wxID_EXIT, MyFrame::OnExit)
EVT_MENU( ID_NEW_WINDOW, MyFrame::OnNewWindow)
EVT_MENU( ID_DEF_ROTATE_LEFT_KEY, MyFrame::OnDefRotateLeftKey)
EVT_MENU( ID_DEF_ROTATE_RIGHT_KEY, MyFrame::OnDefRotateRightKey)
EVT_MENU(wxID_NEW, MyFrame::OnNewWindow)
END_EVENT_TABLE()
// My frame constructor
MyFrame::MyFrame(wxWindow *parent, const wxString& title, const wxPoint& pos,
const wxSize& size, long style)
: wxFrame(parent, wxID_ANY, title, pos, size, style)
MyFrame::MyFrame()
: wxFrame(NULL, wxID_ANY, _T("wxWidgets OpenGL Cube Sample"),
wxDefaultPosition, wxSize(400, 300))
{
m_canvas = NULL;
SetIcon(wxIcon(sample_xpm));
m_canvas = new TestGLCanvas(this);
SetIcon(wxICON(sample));
// Make a menubar
wxMenu *winMenu = new wxMenu;
winMenu->Append(wxID_EXIT, _T("&Close"));
winMenu->Append(wxID_NEW, _T("&New") );
wxMenuBar *menuBar = new wxMenuBar;
menuBar->Append(winMenu, _T("&Window"));
SetMenuBar(menuBar);
Show();
}
// Intercept menu commands
void MyFrame::OnExit( wxCommandEvent& WXUNUSED(event) )
{
// true is to force the frame to close
Close(true);
}
/*static*/ MyFrame *MyFrame::Create(MyFrame *parentFrame, bool isCloneWindow)
{
wxString str = wxT("wxWidgets OpenGL Cube Sample");
if (isCloneWindow) str += wxT(" - Clone");
MyFrame *frame = new MyFrame(NULL, str, wxDefaultPosition,
wxSize(400, 300));
// Make a menubar
wxMenu *winMenu = new wxMenu;
winMenu->Append(wxID_EXIT, _T("&Close"));
winMenu->Append(ID_NEW_WINDOW, _T("&New") );
wxMenuBar *menuBar = new wxMenuBar;
menuBar->Append(winMenu, _T("&Window"));
winMenu = new wxMenu;
winMenu->Append(ID_DEF_ROTATE_LEFT_KEY, _T("Rotate &left"));
winMenu->Append(ID_DEF_ROTATE_RIGHT_KEY, _T("Rotate &right"));
menuBar->Append(winMenu, _T("&Key"));
frame->SetMenuBar(menuBar);
if (parentFrame)
{
frame->m_canvas = new TestGLCanvas( frame, parentFrame->m_canvas,
wxID_ANY, wxDefaultPosition, wxDefaultSize );
}
else
{
frame->m_canvas = new TestGLCanvas(frame, wxID_ANY,
wxDefaultPosition, wxDefaultSize);
}
// Show the frame
frame->Show(true);
return frame;
}
void MyFrame::OnNewWindow( wxCommandEvent& WXUNUSED(event) )
{
(void) Create(this, true);
(void) new MyFrame();
}
void MyFrame::OnDefRotateLeftKey( wxCommandEvent& WXUNUSED(event) )
{
ScanCodeDialog dial( this, wxID_ANY, m_canvas->m_rleft,
wxString(_T("Left")), _T("Define key") );
int result = dial.ShowModal();
if( result == wxID_OK )
m_canvas->m_rleft = dial.GetValue();
}
void MyFrame::OnDefRotateRightKey( wxCommandEvent& WXUNUSED(event) )
{
ScanCodeDialog dial( this, wxID_ANY, m_canvas->m_rright,
wxString(_T("Right")), _T("Define key") );
int result = dial.ShowModal();
if( result == wxID_OK )
m_canvas->m_rright = dial.GetValue();
}
/*------------------------------------------------------------------
Application object ( equivalent to main() )
------------------------------------------------------------------ */
IMPLEMENT_APP(MyApp)
bool MyApp::OnInit()
{
if ( !wxApp::OnInit() )
return false;
// Create the main frame window
(void) MyFrame::Create(NULL);
return true;
}

72
samples/opengl/cube/cube.h
View File

@@ -18,7 +18,18 @@
class MyApp: public wxApp
{
public:
bool OnInit();
MyApp() { m_glContext = NULL; }
// set the specified canvas for current output
void SetCurrent(wxGLCanvas *canvas);
// virtual wxApp methods
virtual bool OnInit();
virtual int OnExit();
private:
// the GL context we use for all our windows
wxGLContext *m_glContext;
};
// Define a new frame type
@@ -27,7 +38,7 @@ class TestGLCanvas;
class MyFrame: public wxFrame
{
public:
static MyFrame *Create(MyFrame *parentFrame, bool isCloneWindow = false);
MyFrame();
void OnExit(wxCommandEvent& event);
void OnNewWindow(wxCommandEvent& event);
@@ -35,70 +46,33 @@ public:
void OnDefRotateRightKey(wxCommandEvent& event);
private:
MyFrame(wxWindow *parent, const wxString& title, const wxPoint& pos,
const wxSize& size, long style = wxDEFAULT_FRAME_STYLE);
TestGLCanvas *m_canvas;
DECLARE_EVENT_TABLE()
};
#if wxUSE_GLCANVAS
class TestGLCanvas : public wxGLCanvas
{
friend class MyFrame;
public:
TestGLCanvas( wxWindow *parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0, const wxString& name = _T("TestGLCanvas") );
TestGLCanvas( wxWindow *parent, const TestGLCanvas *other,
wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = _T("TestGLCanvas") );
~TestGLCanvas();
TestGLCanvas(wxWindow *parent);
void OnPaint(wxPaintEvent& event);
void OnSize(wxSizeEvent& event);
void OnEraseBackground(wxEraseEvent& event);
void OnKeyDown(wxKeyEvent& event);
void OnKeyUp(wxKeyEvent& event);
void OnEnterWindow(wxMouseEvent& event);
void Render();
void InitGL();
void Rotate(GLfloat deg);
static GLfloat CalcRotateSpeed(unsigned long acceltime);
static GLfloat CalcRotateAngle( unsigned long lasttime,
unsigned long acceltime );
void Action( long code, unsigned long lasttime,
unsigned long acceltime );
private:
bool m_init;
// one-time OpenGL initialization
void InitGL();
// render to window
void Render();
// the list of commands to draw the cube
GLuint m_gllist;
long m_rleft;
long m_rright;
static unsigned long m_secbase;
static int m_TimeInitialized;
static unsigned long m_xsynct;
static unsigned long m_gsynct;
long m_Key;
unsigned long m_StartTime;
unsigned long m_LastTime;
unsigned long m_LastRedraw;
DECLARE_EVENT_TABLE()
};
#endif // #if wxUSE_GLCANVAS
#endif // #ifndef _WX_CUBE_H_
#endif // _WX_CUBE_H_