samples/opengl/cube/cube.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        cube.cpp
   3 // Purpose:     wxGLCanvas demo program
   4 // Author:      Julian Smart
   5 // Modified by: Vadim Zeitlin to use new wxGLCanvas API (2007-04-09)
   6 // Created:     04/01/98
   7 // Copyright:   (c) Julian Smart
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 // For compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23 #pragma hdrstop
  24 #endif
  25
  26 #ifndef WX_PRECOMP
  27 #include "wx/wx.h"
  28 #endif
  29
  30 #if !wxUSE_GLCANVAS
  31     #error "OpenGL required: set wxUSE_GLCANVAS to 1 and rebuild the library"
  32 #endif
  33
  34 #include "cube.h"
  35
  36 #ifndef wxHAS_IMAGES_IN_RESOURCES
  37     #include "../../sample.xpm"
  38 #endif
  39
  40 // ----------------------------------------------------------------------------
  41 // constants
  42 // ----------------------------------------------------------------------------
  43
  44 // control ids
  45 enum
  46 {
  47     SpinTimer = wxID_HIGHEST + 1
  48 };
  49
  50 // ----------------------------------------------------------------------------
  51 // helper functions
  52 // ----------------------------------------------------------------------------
  53
  54 static void CheckGLError()
  55 {
  56     GLenum errLast = GL_NO_ERROR;
  57
  58     for ( ;; )
  59     {
  60         GLenum err = glGetError();
  61         if ( err == GL_NO_ERROR )
  62             return;
  63
  64         // normally the error is reset by the call to glGetError() but if
  65         // glGetError() itself returns an error, we risk looping forever here
  66         // so check that we get a different error than the last time
  67         if ( err == errLast )
  68         {
  69             wxLogError(wxT("OpenGL error state couldn't be reset."));
  70             return;
  71         }
  72
  73         errLast = err;
  74
  75         wxLogError(wxT("OpenGL error %d"), err);
  76     }
  77 }
  78
  79 // function to draw the texture for cube faces
  80 static wxImage DrawDice(int size, unsigned num)
  81 {
  82     wxASSERT_MSG( num >= 1 && num <= 6, wxT("invalid dice index") );
  83
  84     const int dot = size/16;        // radius of a single dot
  85     const int gap = 5*size/32;      // gap between dots
  86
  87     wxBitmap bmp(size, size);
  88     wxMemoryDC dc;
  89     dc.SelectObject(bmp);
  90     dc.SetBackground(*wxWHITE_BRUSH);
  91     dc.Clear();
  92     dc.SetBrush(*wxBLACK_BRUSH);
  93
  94     // the upper left and lower right points
  95     if ( num != 1 )
  96     {
  97         dc.DrawCircle(gap + dot, gap + dot, dot);
  98         dc.DrawCircle(size - gap - dot, size - gap - dot, dot);
  99     }
 100
 101     // draw the central point for odd dices
 102     if ( num % 2 )
 103     {
 104         dc.DrawCircle(size/2, size/2, dot);
 105     }
 106
 107     // the upper right and lower left points
 108     if ( num > 3 )
 109     {
 110         dc.DrawCircle(size - gap - dot, gap + dot, dot);
 111         dc.DrawCircle(gap + dot, size - gap - dot, dot);
 112     }
 113
 114     // finally those 2 are only for the last dice
 115     if ( num == 6 )
 116     {
 117         dc.DrawCircle(gap + dot, size/2, dot);
 118         dc.DrawCircle(size - gap - dot, size/2, dot);
 119     }
 120
 121     dc.SelectObject(wxNullBitmap);
 122
 123     return bmp.ConvertToImage();
 124 }
 125
 126 // ============================================================================
 127 // implementation
 128 // ============================================================================
 129
 130 // ----------------------------------------------------------------------------
 131 // TestGLContext
 132 // ----------------------------------------------------------------------------
 133
 134 TestGLContext::TestGLContext(wxGLCanvas *canvas)
 135              : wxGLContext(canvas)
 136 {
 137     SetCurrent(*canvas);
 138
 139     // set up the parameters we want to use
 140     glEnable(GL_CULL_FACE);
 141     glEnable(GL_DEPTH_TEST);
 142     glEnable(GL_LIGHTING);
 143     glEnable(GL_LIGHT0);
 144     glEnable(GL_TEXTURE_2D);
 145
 146     // add slightly more light, the default lighting is rather dark
 147     GLfloat ambient[] = { 0.5, 0.5, 0.5, 0.5 };
 148     glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
 149
 150     // set viewing projection
 151     glMatrixMode(GL_PROJECTION);
 152     glLoadIdentity();
 153     glFrustum(-0.5f, 0.5f, -0.5f, 0.5f, 1.0f, 3.0f);
 154
 155     // create the textures to use for cube sides: they will be reused by all
 156     // canvases (which is probably not critical in the case of simple textures
 157     // we use here but could be really important for a real application where
 158     // each texture could take many megabytes)
 159     glGenTextures(WXSIZEOF(m_textures), m_textures);
 160
 161     for ( unsigned i = 0; i < WXSIZEOF(m_textures); i++ )
 162     {
 163         glBindTexture(GL_TEXTURE_2D, m_textures[i]);
 164
 165         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 166         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
 167         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 168         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 169         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 170
 171         const wxImage img(DrawDice(256, i + 1));
 172
 173         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 174         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, img.GetWidth(), img.GetHeight(),
 175                      0, GL_RGB, GL_UNSIGNED_BYTE, img.GetData());
 176     }
 177
 178     CheckGLError();
 179 }
 180
 181 void TestGLContext::DrawRotatedCube(float xangle, float yangle)
 182 {
 183     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 184
 185     glMatrixMode(GL_MODELVIEW);
 186     glLoadIdentity();
 187     glTranslatef(0.0f, 0.0f, -2.0f);
 188     glRotatef(xangle, 1.0f, 0.0f, 0.0f);
 189     glRotatef(yangle, 0.0f, 1.0f, 0.0f);
 190
 191     // draw six faces of a cube of size 1 centered at (0, 0, 0)
 192     glBindTexture(GL_TEXTURE_2D, m_textures[0]);
 193     glBegin(GL_QUADS);
 194         glNormal3f( 0.0f, 0.0f, 1.0f);
 195         glTexCoord2f(0, 0); glVertex3f( 0.5f, 0.5f, 0.5f);
 196         glTexCoord2f(1, 0); glVertex3f(-0.5f, 0.5f, 0.5f);
 197         glTexCoord2f(1, 1); glVertex3f(-0.5f,-0.5f, 0.5f);
 198         glTexCoord2f(0, 1); glVertex3f( 0.5f,-0.5f, 0.5f);
 199     glEnd();
 200
 201     glBindTexture(GL_TEXTURE_2D, m_textures[1]);
 202     glBegin(GL_QUADS);
 203         glNormal3f( 0.0f, 0.0f,-1.0f);
 204         glTexCoord2f(0, 0); glVertex3f(-0.5f,-0.5f,-0.5f);
 205         glTexCoord2f(1, 0); glVertex3f(-0.5f, 0.5f,-0.5f);
 206         glTexCoord2f(1, 1); glVertex3f( 0.5f, 0.5f,-0.5f);
 207         glTexCoord2f(0, 1); glVertex3f( 0.5f,-0.5f,-0.5f);
 208     glEnd();
 209
 210     glBindTexture(GL_TEXTURE_2D, m_textures[2]);
 211     glBegin(GL_QUADS);
 212         glNormal3f( 0.0f, 1.0f, 0.0f);
 213         glTexCoord2f(0, 0); glVertex3f( 0.5f, 0.5f, 0.5f);
 214         glTexCoord2f(1, 0); glVertex3f( 0.5f, 0.5f,-0.5f);
 215         glTexCoord2f(1, 1); glVertex3f(-0.5f, 0.5f,-0.5f);
 216         glTexCoord2f(0, 1); glVertex3f(-0.5f, 0.5f, 0.5f);
 217     glEnd();
 218
 219     glBindTexture(GL_TEXTURE_2D, m_textures[3]);
 220     glBegin(GL_QUADS);
 221         glNormal3f( 0.0f,-1.0f, 0.0f);
 222         glTexCoord2f(0, 0); glVertex3f(-0.5f,-0.5f,-0.5f);
 223         glTexCoord2f(1, 0); glVertex3f( 0.5f,-0.5f,-0.5f);
 224         glTexCoord2f(1, 1); glVertex3f( 0.5f,-0.5f, 0.5f);
 225         glTexCoord2f(0, 1); glVertex3f(-0.5f,-0.5f, 0.5f);
 226     glEnd();
 227
 228     glBindTexture(GL_TEXTURE_2D, m_textures[4]);
 229     glBegin(GL_QUADS);
 230         glNormal3f( 1.0f, 0.0f, 0.0f);
 231         glTexCoord2f(0, 0); glVertex3f( 0.5f, 0.5f, 0.5f);
 232         glTexCoord2f(1, 0); glVertex3f( 0.5f,-0.5f, 0.5f);
 233         glTexCoord2f(1, 1); glVertex3f( 0.5f,-0.5f,-0.5f);
 234         glTexCoord2f(0, 1); glVertex3f( 0.5f, 0.5f,-0.5f);
 235     glEnd();
 236
 237     glBindTexture(GL_TEXTURE_2D, m_textures[5]);
 238     glBegin(GL_QUADS);
 239         glNormal3f(-1.0f, 0.0f, 0.0f);
 240         glTexCoord2f(0, 0); glVertex3f(-0.5f,-0.5f,-0.5f);
 241         glTexCoord2f(1, 0); glVertex3f(-0.5f,-0.5f, 0.5f);
 242         glTexCoord2f(1, 1); glVertex3f(-0.5f, 0.5f, 0.5f);
 243         glTexCoord2f(0, 1); glVertex3f(-0.5f, 0.5f,-0.5f);
 244     glEnd();
 245
 246     glFlush();
 247
 248     CheckGLError();
 249 }
 250
 251
 252 // ----------------------------------------------------------------------------
 253 // MyApp: the application object
 254 // ----------------------------------------------------------------------------
 255
 256 IMPLEMENT_APP(MyApp)
 257
 258 bool MyApp::OnInit()
 259 {
 260     if ( !wxApp::OnInit() )
 261         return false;
 262
 263     new MyFrame();
 264
 265     return true;
 266 }
 267
 268 int MyApp::OnExit()
 269 {
 270     delete m_glContext;
 271
 272     return wxApp::OnExit();
 273 }
 274
 275 TestGLContext& MyApp::GetContext(wxGLCanvas *canvas)
 276 {
 277     if ( !m_glContext )
 278     {
 279         // Create the OpenGL context for the first window which needs it:
 280         // subsequently created windows will all share the same context.
 281         m_glContext = new TestGLContext(canvas);
 282     }
 283
 284     m_glContext->SetCurrent(*canvas);
 285
 286     return *m_glContext;
 287 }
 288
 289 // ----------------------------------------------------------------------------
 290 // TestGLCanvas
 291 // ----------------------------------------------------------------------------
 292
 293 BEGIN_EVENT_TABLE(TestGLCanvas, wxGLCanvas)
 294     EVT_PAINT(TestGLCanvas::OnPaint)
 295     EVT_KEY_DOWN(TestGLCanvas::OnKeyDown)
 296     EVT_TIMER(SpinTimer, TestGLCanvas::OnSpinTimer)
 297 END_EVENT_TABLE()
 298
 299 TestGLCanvas::TestGLCanvas(wxWindow *parent)
 300     // With perspective OpenGL graphics, the wxFULL_REPAINT_ON_RESIZE style
 301     // flag should always be set, because even making the canvas smaller should
 302     // be followed by a paint event that updates the entire canvas with new
 303     // viewport settings.
 304     : wxGLCanvas(parent, wxID_ANY, NULL /* attribs */,
 305                  wxDefaultPosition, wxDefaultSize,
 306                  wxFULL_REPAINT_ON_RESIZE),
 307       m_xangle(30.0),
 308       m_yangle(30.0),
 309       m_spinTimer(this,SpinTimer)
 310 {
 311 }
 312
 313 void TestGLCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
 314 {
 315     // This is required even though dc is not used otherwise.
 316     wxPaintDC dc(this);
 317
 318     // Set the OpenGL viewport according to the client size of this canvas.
 319     // This is done here rather than in a wxSizeEvent handler because our
 320     // OpenGL rendering context (and thus viewport setting) is used with
 321     // multiple canvases: If we updated the viewport in the wxSizeEvent
 322     // handler, changing the size of one canvas causes a viewport setting that
 323     // is wrong when next another canvas is repainted.
 324     const wxSize ClientSize = GetClientSize();
 325
 326     TestGLContext& canvas = wxGetApp().GetContext(this);
 327     glViewport(0, 0, ClientSize.x, ClientSize.y);
 328
 329     // Render the graphics and swap the buffers.
 330     canvas.DrawRotatedCube(m_xangle, m_yangle);
 331     SwapBuffers();
 332 }
 333
 334 void TestGLCanvas::Spin(float xSpin, float ySpin)
 335 {
 336     m_xangle += xSpin;
 337     m_yangle += ySpin;
 338
 339     Refresh(false);
 340 }
 341
 342 void TestGLCanvas::OnKeyDown(wxKeyEvent& event)
 343 {
 344     float angle = 5.0;
 345
 346     switch ( event.GetKeyCode() )
 347     {
 348         case WXK_RIGHT:
 349             Spin( 0.0, -angle );
 350             break;
 351
 352         case WXK_LEFT:
 353             Spin( 0.0, angle );
 354             break;
 355
 356         case WXK_DOWN:
 357             Spin( -angle, 0.0 );
 358             break;
 359
 360         case WXK_UP:
 361             Spin( angle, 0.0 );
 362             break;
 363
 364         case WXK_SPACE:
 365             if ( m_spinTimer.IsRunning() )
 366                 m_spinTimer.Stop();
 367             else
 368                 m_spinTimer.Start( 25 );
 369             break;
 370
 371         default:
 372             event.Skip();
 373             return;
 374     }
 375 }
 376
 377 void TestGLCanvas::OnSpinTimer(wxTimerEvent& WXUNUSED(event))
 378 {
 379     Spin(0.0, 4.0);
 380 }
 381
 382
 383 // ----------------------------------------------------------------------------
 384 // MyFrame: main application window
 385 // ----------------------------------------------------------------------------
 386
 387 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 388     EVT_MENU(wxID_NEW, MyFrame::OnNewWindow)
 389     EVT_MENU(wxID_CLOSE, MyFrame::OnClose)
 390 END_EVENT_TABLE()
 391
 392 MyFrame::MyFrame()
 393        : wxFrame(NULL, wxID_ANY, wxT("wxWidgets OpenGL Cube Sample"))
 394 {
 395     new TestGLCanvas(this);
 396
 397     SetIcon(wxICON(sample));
 398
 399     // Make a menubar
 400     wxMenu *menu = new wxMenu;
 401     menu->Append(wxID_NEW);
 402     menu->AppendSeparator();
 403     menu->Append(wxID_CLOSE);
 404     wxMenuBar *menuBar = new wxMenuBar;
 405     menuBar->Append(menu, wxT("&Cube"));
 406
 407     SetMenuBar(menuBar);
 408
 409     CreateStatusBar();
 410
 411     SetClientSize(400, 400);
 412     Show();
 413
 414     // test IsDisplaySupported() function:
 415     static const int attribs[] = { WX_GL_RGBA, WX_GL_DOUBLEBUFFER, 0 };
 416     wxLogStatus("Double-buffered display %s supported",
 417                 wxGLCanvas::IsDisplaySupported(attribs) ? "is" : "not");
 418 }
 419
 420 void MyFrame::OnClose(wxCommandEvent& WXUNUSED(event))
 421 {
 422     // true is to force the frame to close
 423     Close(true);
 424 }
 425
 426 void MyFrame::OnNewWindow( wxCommandEvent& WXUNUSED(event) )
 427 {
 428     new MyFrame();
 429 }
 430