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

Add a new OpenGL pyramid sample

Browse Source 
This sample shows the use of modern OpenGL (3.2).

Closes #16910.
This commit is contained in:
Manuel Martin
2016-02-23 00:52:28 +01:00
committed by Vadim Zeitlin
parent bdc95f5766
commit d6fb44e158
27 changed files with 6418 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

599
samples/opengl/pyramid/pyramid.cpp Normal file
View File

@@ -0,0 +1,599 @@
/////////////////////////////////////////////////////////////////////////////
// Name: pyramid.cpp
// Purpose: OpenGL version >= 3.2 sample
// Author: Manuel Martin
// Created: 2015/11/16
// Copyright: (c) 2015 Manuel Martin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#if !wxUSE_GLCANVAS
#error "OpenGL required: set wxUSE_GLCANVAS to 1 and rebuild the library"
#endif
// Due to oglpfuncs.h needs to be included before gl.h (to avoid some declarations),
// we include glcanvas.h after oglstuff.h
#include "oglstuff.h"
#include "wx/glcanvas.h"
#include "pyramid.h"
// the application icon (under Windows and OS/2 it is in resources and even
// though we could still include the XPM here it would be unused)
#ifndef wxHAS_IMAGES_IN_RESOURCES
#include "../../sample.xpm"
#endif
wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_MENU(Pyramid_Quit, MyFrame::OnQuit)
EVT_MENU(Pyramid_About, MyFrame::OnAbout)
#if wxUSE_LOGWINDOW
EVT_MENU(Pyramid_LogW, MyFrame::OnLogWindow)
#endif // wxUSE_LOGWINDOW
wxEND_EVENT_TABLE()
wxIMPLEMENT_APP(MyApp);
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// the application class
// ----------------------------------------------------------------------------
// 'Main program' equivalent: the program execution "starts" here
bool MyApp::OnInit()
{
if ( !wxApp::OnInit() )
return false;
// create the main application window
MyFrame* frame = new MyFrame("wxWidgets OpenGL Pyramid Sample");
//Exit if the required visual attributes or OGL context couldn't be created
if ( ! frame->OGLAvailable() )
return false;
// As of October 2015 GTK+ needs the frame to be shown before we call SetCurrent()
frame->Show(true);
return true;
}
// ----------------------------------------------------------------------------
// main frame
// ----------------------------------------------------------------------------
// frame constructor
MyFrame::MyFrame(const wxString& title)
: wxFrame(NULL, wxID_ANY, title, wxDefaultPosition, wxSize(500, 400))
{
// set the frame icon
SetIcon(wxICON(sample));
#if wxUSE_MENUS
// create a menu bar
wxMenu *fileMenu = new wxMenu;
// the "About" item should be in the help menu
wxMenu *helpMenu = new wxMenu;
helpMenu->Append(Pyramid_About, "&About\tF1", "Show about dialog");
#if wxUSE_LOGWINDOW
fileMenu->Append(Pyramid_LogW, "&Log window", "Open the log window");
fileMenu->AppendSeparator();
#endif // wxUSE_LOGWINDOW
fileMenu->Append(Pyramid_Quit, "E&xit\tAlt-X", "Quit this program");
// now append the freshly created menu to the menu bar...
wxMenuBar *menuBar = new wxMenuBar();
menuBar->Append(fileMenu, "&File");
menuBar->Append(helpMenu, "&Help");
// ... and attach this menu bar to the frame
SetMenuBar(menuBar);
#endif // wxUSE_MENUS
#if wxUSE_STATUSBAR
// create a status bar just for fun (by default with 1 pane only)
CreateStatusBar(2);
SetStatusText("Welcome to wxWidgets!");
#endif // wxUSE_STATUSBAR
#if wxUSE_LOGWINDOW
//Open a log window, don't show it though
m_LogWin = new wxLogWindow(NULL, "Pyramid log window", false, false);
wxLog::SetActiveTarget(m_LogWin);
#endif // wxUSE_LOGWINDOW
// The canvas
m_mycanvas = NULL;
wxGLAttributes vAttrs;
// Defaults should be accepted
vAttrs.PlatformDefaults().Defaults().EndList();
bool accepted = wxGLCanvas::IsDisplaySupported(vAttrs) ;
if ( accepted )
{
#if wxUSE_LOGWINDOW
wxLogMessage("The display supports required visual attributes.");
#endif // wxUSE_LOGWINDOW
}
else
{
#if wxUSE_LOGWINDOW
wxLogMessage("First try with OpenGL default visual attributes failed.");
#endif // wxUSE_LOGWINDOW
// Try again without sample buffers
vAttrs.Reset();
vAttrs.PlatformDefaults().RGBA().DoubleBuffer().Depth(16).EndList();
accepted = wxGLCanvas::IsDisplaySupported(vAttrs) ;
if ( !accepted )
{
wxMessageBox("Visual attributes for OpenGL are not accepted.\nThe app will exit now.",
"Error with OpenGL", wxOK | wxICON_ERROR);
}
else
{
#if wxUSE_LOGWINDOW
wxLogMessage("Second try with other visual attributes worked.");
#endif // wxUSE_LOGWINDOW
}
}
if ( accepted )
m_mycanvas = new MyGLCanvas(this, vAttrs);
SetMinSize(wxSize(250, 200));
}
// event handlers
void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
// true is to force the frame to close
Close(true);
}
void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
wxMessageBox(wxString::Format
(
"Welcome to %s!\n"
"\n"
"This is the wxWidgets OpenGL Pyramid sample.\n"
"%s\n",
wxVERSION_STRING,
m_OGLString
),
"About wxWidgets pyramid sample",
wxOK | wxICON_INFORMATION,
this);
}
#if wxUSE_LOGWINDOW
void MyFrame::OnLogWindow(wxCommandEvent& WXUNUSED(event))
{
if ( m_LogWin->GetFrame()->IsIconized() )
m_LogWin->GetFrame()->Restore();
if ( ! m_LogWin->GetFrame()->IsShown() )
m_LogWin->Show();
m_LogWin->GetFrame()->SetFocus();
}
#endif // wxUSE_LOGWINDOW
bool MyFrame::OGLAvailable()
{
//Test if visual attributes were accepted.
if ( ! m_mycanvas )
return false;
//Test if OGL context could be created.
return m_mycanvas->OglCtxAvailable();
}
// ----------------------------------------------------------------------------
// Function for receiving messages from OGLstuff and passing them to the log window
// ----------------------------------------------------------------------------
void fOGLErrHandler(int err, int glerr, const GLchar* glMsg)
{
#if wxUSE_LOGWINDOW
wxString msg;
switch (err)
{
case myoglERR_SHADERCREATE:
msg = _("Error in shader creation.");
break;
case myoglERR_SHADERCOMPILE:
msg = _("Error in shader compilation.");
break;
case myoglERR_SHADERLINK:
msg = _("Error in shader linkage.");
break;
case myoglERR_SHADERLOCATION:
msg = _("Error: Can't get uniforms locations.");
break;
case myoglERR_BUFFER:
msg = _("Error: Can't load buffer. Likely out of GPU memory.");
break;
case myoglERR_TEXTIMAGE:
msg = _("Error: Can't load texture. Likely out of GPU memory.");
break;
case myoglERR_DRAWING_TRI:
msg = _("Error: Can't draw the triangles.");
break;
case myoglERR_DRAWING_STR:
msg = _("Error: Can't draw the string.");
break;
case myoglERR_JUSTLOG:
msg = _("Log info: ");
break;
default:
msg = _("Not a GL message.");
}
if ( glerr != GL_NO_ERROR )
msg += wxString::Format(_(" GL error %d. "), glerr);
else if ( err == 0 )
msg = _("Information: ");
else if ( err != myoglERR_JUSTLOG )
msg += _(" GL reports: ");
if ( glMsg != NULL )
msg += wxString::FromUTF8( reinterpret_cast<const char *>(glMsg) );
wxLogMessage(msg);
#endif // wxUSE_LOGWINDOW
}
// ----------------------------------------------------------------------------
// These two functions allow us to convert a wxString into a RGBA pixels array
// ----------------------------------------------------------------------------
// Creates a 4-bytes-per-pixel, RGBA array from a wxImage.
// If the image has alpha channel, it's used. If not, pixels with 'cTrans' color
// get 'cAlpha' alpha; an the rest of pixels get alpha=255 (opaque).
//
// NOTE: The returned pointer must be deleted somewhere in the app.
unsigned char* MyImgToArray(const wxImage& img, const wxColour& cTrans, unsigned char cAlpha)
{
int w = img.GetWidth();
int h = img.GetHeight();
int siz = w * h;
unsigned char *resArr = new unsigned char [siz * 4];
unsigned char *res = resArr;
unsigned char *sdata = img.GetData();
unsigned char *alpha = NULL;
if ( img.HasAlpha() )
alpha = img.GetAlpha();
// Pixel by pixel
for ( int i = 0; i < siz; i++ )
{ //copy the colour
res[0] = sdata[0] ;
res[1] = sdata[1] ;
res[2] = sdata[2] ;
if ( alpha != NULL )
{ //copy alpha
res[3] = alpha[i] ;
}
else
{ // Colour cTrans gets cAlpha transparency
if ( res[0] == cTrans.Red() && res[1] == cTrans.Green() && res[2] == cTrans.Blue() )
res[3] = cAlpha;
else
res[3] = 255 ;
}
sdata += 3 ;
res += 4 ;
}
return resArr;
}
// Creates an array of bytes that defines the pixels of the string.
// The background color has cAlpha transparency. 0=transparent, 255=opaque
//
// NOTE: The returned pointer must be deleted somewhere in the app.
unsigned char* MyTextToPixels(const wxString& sText, // The string
const wxFont& sFont, // Font to use
const wxColour& sForeColo, // Foreground colour
const wxColour& sBackColo, // Background colour
unsigned char cAlpha, // Background transparency
int* width, int* height) // Image sizes
{
if ( sText.IsEmpty() )
return NULL;
// The dc where we temporally draw
wxMemoryDC mdc;
mdc.SetFont(sFont);
// Measure
mdc.GetMultiLineTextExtent(sText, width, height);
/* This code should be used for old graphics cards.
But this sample uses OGL Core Profile, so the card is not that old.
// Adjust sizes to power of two. Needed for old cards.
int sizP2 = 4;
while ( sizP2 < *width )
sizP2 *= 2;
*width = sizP2;
sizP2 = 4;
while ( sizP2 < *height )
sizP2 *= 2;
*height = sizP2;
*/
// Now we know dimensions, let's draw into a memory dc
wxBitmap bmp(*width, *height, 24);
mdc.SelectObject(bmp);
// If we have multiline string, perhaps not all of the bmp is used
wxBrush brush(sBackColo);
mdc.SetBackground(brush);
mdc.Clear(); // Make sure all of bmp is cleared
// Colours
mdc.SetBackgroundMode(wxPENSTYLE_SOLID);
mdc.SetTextBackground(sBackColo);
mdc.SetTextForeground(sForeColo);
// We draw the string and get it as an image.
// NOTE: OpenGL axis are bottom to up. Be aware when setting the texture coords.
mdc.DrawText(sText, 0, 0);
mdc.SelectObject(wxNullBitmap); // bmp must be detached from wxMemoryDC
// Bytes from the image. Background pixels become transparent with the
// cAlpha transparency value.
unsigned char *res = MyImgToArray(bmp.ConvertToImage(), sBackColo, cAlpha);
return res;
}
// ----------------------------------------------------------------------------
// The canvas inside the frame. Our OpenGL connection
// ----------------------------------------------------------------------------
wxBEGIN_EVENT_TABLE(MyGLCanvas, wxGLCanvas)
EVT_PAINT(MyGLCanvas::OnPaint)
EVT_SIZE(MyGLCanvas::OnSize)
EVT_MOUSE_EVENTS(MyGLCanvas::OnMouse)
wxEND_EVENT_TABLE()
//We create a wxGLContext in this constructor.
//We do OGL initialization at OnSize().
MyGLCanvas::MyGLCanvas(MyFrame* parent, const wxGLAttributes& canvasAttrs)
: wxGLCanvas(parent, canvasAttrs)
{
m_parent = parent;
m_oglManager = NULL;
m_winHeight = 0; // We have not been sized yet
// Explicitly create a new rendering context instance for this canvas.
wxGLContextAttrs ctxAttrs;
#ifndef __WXMAC__
// An impossible context, just to test IsOk()
ctxAttrs.PlatformDefaults().OGLVersion(99, 2).EndList();
m_oglContext = new wxGLContext(this, NULL, &ctxAttrs);
if ( !m_oglContext->IsOK() )
{
#if wxUSE_LOGWINDOW
wxLogMessage("Trying to set OpenGL 99.2 failed, as expected.");
#endif // wxUSE_LOGWINDOW
delete m_oglContext;
ctxAttrs.Reset();
#endif //__WXMAC__
ctxAttrs.PlatformDefaults().CoreProfile().OGLVersion(3, 2).EndList();
m_oglContext = new wxGLContext(this, NULL, &ctxAttrs);
#ifndef __WXMAC__
}
#endif //__WXMAC__
if ( !m_oglContext->IsOK() )
{
wxMessageBox("This sample needs an OpenGL 3.2 capable driver.\nThe app will end now.",
"OpenGL version error", wxOK | wxICON_INFORMATION, this);
delete m_oglContext;
m_oglContext = NULL;
}
else
{
#if wxUSE_LOGWINDOW
wxLogMessage("OpenGL Core Profile 3.2 successfully set.");
#endif // wxUSE_LOGWINDOW
}
}
MyGLCanvas::~MyGLCanvas()
{
if ( m_oglContext )
SetCurrent(*m_oglContext);
if ( m_oglManager )
{
delete m_oglManager;
m_oglManager = NULL;
}
if ( m_oglContext )
{
delete m_oglContext;
m_oglContext = NULL;
}
}
bool MyGLCanvas::oglInit()
{
if ( !m_oglContext )
return false;
// The current context must be set before we get OGL pointers
SetCurrent(*m_oglContext);
// Initialize our OGL pointers
if ( !myOGLManager::Init() )
{
wxMessageBox("Error: Some OpenGL pointer to function failed.",
"OpenGL initialization error", wxOK | wxICON_INFORMATION, this);
return false;
}
// Create our OGL manager, pass our OGL error handler
m_oglManager = new myOGLManager(&fOGLErrHandler);
// Get the GL version for the current OGL context
wxString sglVer = "\nUsing OpenGL version: ";
sglVer += wxString::FromUTF8(
reinterpret_cast<const char *>(m_oglManager->GetGLVersion()) );
// Also Vendor and Renderer
sglVer += "\nVendor: ";
sglVer += wxString::FromUTF8(
reinterpret_cast<const char *>(m_oglManager->GetGLVendor()) );
sglVer += "\nRenderer: ";
sglVer += wxString::FromUTF8(
reinterpret_cast<const char *>(m_oglManager->GetGLRenderer()) );
// For the menu "About" info
m_parent->SetOGLString(sglVer);
// Load some data into GPU
m_oglManager->SetShadersAndTriangles();
// This string will be placed on a face of the pyramid
int swi = 0, shi = 0; //Image sizes
wxString stg("wxWidgets");
// Set the font. Use a big pointsize so as to smoothing edges.
wxFont font(48, wxFONTFAMILY_MODERN, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
if ( !font.IsOk() )
font = *wxSWISS_FONT;
wxColour bgrdColo(*wxBLACK);
wxColour foreColo(160, 0, 200); // Dark purple
// Build an array with the pixels. Background fully transparent
unsigned char* sPixels = MyTextToPixels(stg, font, foreColo, bgrdColo, 0,
&swi, &shi);
// Send it to GPU
m_oglManager->SetStringOnPyr(sPixels, swi, shi);
delete[] sPixels; // That memory was allocated at MyTextToPixels
// This string is placed at left bottom of the window. Its size doesn't
// change with window size.
stg = "Rotate the pyramid with\nthe left mouse button";
font.SetPointSize(14);
bgrdColo = wxColour(40, 40, 255);
foreColo = wxColour(*wxWHITE);
unsigned char* stPixels = MyTextToPixels(stg, font, foreColo, bgrdColo, 80,
&swi, &shi);
m_oglManager->SetImmutableString(stPixels, swi, shi);
delete[] stPixels;
return true;
}
void MyGLCanvas::OnPaint( wxPaintEvent& WXUNUSED(event) )
{
// This is a dummy, to avoid an endless succession of paint messages.
// OnPaint handlers must always create a wxPaintDC.
wxPaintDC dc(this);
// Avoid painting when we have not yet a size
if ( m_winHeight < 1 || !m_oglManager )
return;
// This should not be needed, while we have only one canvas
SetCurrent(*m_oglContext);
// Do the magic
m_oglManager->Render();
SwapBuffers();
}
//Note:
// You may wonder why OpenGL initialization was not done at wxGLCanvas ctor.
// The reason is due to GTK+/X11 working asynchronously, we can't call
// SetCurrent() before the window is shown on screen (GTK+ doc's say that the
// window must be realized first).
// In wxGTK, window creation and sizing requires several size-events. At least
// one of them happens after GTK+ has notified the realization. We use this
// circumstance and do initialization then.
void MyGLCanvas::OnSize(wxSizeEvent& event)
{
event.Skip();
// If this window is not fully initialized, dismiss this event
if ( !IsShownOnScreen() )
return;
if ( !m_oglManager )
{
//Now we have a context, retrieve pointers to OGL functions
if ( !oglInit() )
return;
//Some GPUs need an additional forced paint event
PostSizeEvent();
}
// This is normally only necessary if there is more than one wxGLCanvas
// or more than one wxGLContext in the application.
SetCurrent(*m_oglContext);
// It's up to the application code to update the OpenGL viewport settings.
m_winHeight = event.GetSize().y;
m_oglManager->SetViewport(0, 0, event.GetSize().x, m_winHeight);
// Generate paint event without erasing the background.
Refresh(false);
}
void MyGLCanvas::OnMouse(wxMouseEvent& event)
{
event.Skip();
// GL 0 Y-coordinate is at bottom of the window
int oglwinY = m_winHeight - event.GetY();
if ( event.LeftIsDown() )
{
if ( ! event.Dragging() )
{
// Store positions
m_oglManager->OnMouseButDown(event.GetX(), oglwinY);
}
else
{
// Rotation
m_oglManager->OnMouseRotDragging( event.GetX(), oglwinY );
// Generate paint event without erasing the background.
Refresh(false);
}
}
}