ExampleGLShared.cpp

/* This file is part of the BIAS library (Basic ImageAlgorithmS).

   Copyright (C) 2003-2009    (see file CONTACT for details)
   Vision N GmbH
   Schauenburgerstr. 116
   24118 Kiel
   
   BIAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 of the License, or
   (at your option) any later version.
   
   BIAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public License
   along with BIAS; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA*/

#include <bias_config.h>

//#include <Base/Common/LeakChecking.h>
#include "ExampleGLShared.hh"

// BIAS
#include <Gui/ConsoleRedirectIO.hh>
#include <Gui/GeometryGL.hh>

using namespace std;

// required for wx RTTI dynamic construction: 
IMPLEMENT_APP(ExampleGLSharedApp)

// --------------------------------------------------------
#ifdef BIAS_HAVE_GLUT
#  define GLUT_BUILDING_LIB
#  include <GL/glut.h> 
#endif // BIAS_HAVE_GLUT


///
/// your own implementation of the scenes GL calls: 
///

MyGLCanvas::MyGLCanvas(wxFrame* parent)
: 
BIAS::OpenGLCanvas( parent, -1)
,dplist(0)
{}


void MyGLCanvas::InitGeometry()
{
    // init once: 
    static bool initDone=false;
    if(!initDone)
    {
        // do init 
        CHECK_GL_ERROR;
        // example for an OpenGL display list
        dplist = glGenLists(1); // identifier 
        glNewList(dplist, GL_COMPILE ); // or: GL_COMPILE_AND_EXECUTE
        {
            // light source proeprties for enabled lighting:  
            // specified pos by w=1, direction by w=0:
            GLfloat light_position0[]     = {10.0f, 10.0, 10.0f, 0.0f}; // w=0: direction
            GLfloat light_maincolor0[]    = {1.0f, 1.0, 1.0f, 1.0f};
            GLfloat light_ambientcolor0[] = {0.4f, 0.2f, 0.2f, 1.0f};

            // GL create light 0
            glLightfv(GL_LIGHT0, GL_POSITION, light_position0);
            glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_maincolor0);
            glLightfv(GL_LIGHT0, GL_SPECULAR, light_maincolor0);
            glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambientcolor0);

            glEnable(GL_LIGHT0);
            glEnable(GL_LIGHTING); // may be switched on/off for every object
            glEnable(GL_DEPTH_TEST); // depth buffer occlusions of objects

            // material properties for enabled lighting: 
            GLfloat paintcolor0[]    = { 0.9f, 0.2f, 0.5f, 1.0f};
            GLfloat specularcolor0[] = { 1.0f, 1.0f, 1.0f, 1.0f};
            GLfloat shininess0[]     = { 70.0f }; // 1..128, large values make smaller specular highlights

            GLfloat paintcolor1[]    = { 0.3f, 0.9f, 0.4f, 1.0f};
            GLfloat paintcolor2[]    = { 0.1f, 0.2f, 0.9f, 1.0f};

            glMatrixMode(GL_MODELVIEW);
            glPushMatrix();

            //// activate material properties: 
            glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, specularcolor0);
            glMaterialfv( GL_FRONT_AND_BACK, GL_SHININESS, shininess0);
            glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, 
                paintcolor0);
            glColor3f(
                paintcolor0[0], 
                paintcolor0[1], 
                paintcolor0[2] );

            // draw geometry
            BIAS::Vector3<float> dtea(-0.5f, -0.2f, 0.0f);
            // position of the scene "modeling" matrix
            glTranslatef( dtea[0], dtea[1], dtea[2] );
            // glutteapot has strange vertex ordering for historical reasons
            glFrontFace(GL_CW);
#ifdef BIAS_HAVE_GLUT
            glutSolidTeapot(0.6);
#endif //BIAS_HAVE_GLUT
            glFrontFace(GL_CCW);

            glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, 
                paintcolor1 );
            glColor3f(
                paintcolor1[0], 
                paintcolor1[1], 
                paintcolor1[2] );

            glTranslatef( -2*dtea[0], -2*dtea[1], -2*dtea[2] );
            glFrontFace(GL_CW);
#ifdef BIAS_HAVE_GLUT
            glutSolidTeapot(0.3);
#endif // BIAS_HAVE_GLUT
            glFrontFace(GL_CCW);
            glTranslatef( dtea[0], dtea[1], dtea[2] );
            // back on origin

            // activate material properties: 
            glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, paintcolor2);
            glColor3f(paintcolor2[0], paintcolor2[1], paintcolor2[2]);

#ifdef BIAS_HAVE_GLUT
            glTranslatef(0,0,-2);
            glutSolidSphere(0.8, 30, 60);
            glTranslatef(0,0, 2); // back to origin

            glTranslatef( 1,0,-3);
            glutSolidSphere(0.5, 50, 100);
            glTranslatef(-1,0, 3);// back to origin

            glTranslatef(0,2,0);
            glutSolidCube(0.7);
            glTranslatef(0,-2,0);

            glTranslatef(0,-1,0);
            glutSolidIcosahedron();
            glTranslatef(0, 1,0);

            glTranslatef(0,-2.2,0);
            glutSolidTetrahedron();
            glTranslatef(0, 2.2,0);
#endif // BIAS_HAVE_GLUT

            glPopMatrix();
        }
        glEndList();

        #ifdef BIAS_HAVE_FONTGL
        // font:
#ifdef WIN32
        font.InitFont( GetDC(HWND(GetHandle())), "Arial" );
#else // WIN32
        font.InitFont( GetHandle(), "Arial" );
#endif // WIN32

        #endif // BIAS_HAVE_FONTGL

        CHECK_GL_ERROR;
        initDone=true;
    };
}


void MyGLCanvas::DisplayCalls()
{
    //CALLINFO;
    CHECK_GL_ERROR;
    InitGeometry();

    DisplayClear();
  DisplayCameraView();

    CHECK_GL_ERROR;

    {
        //glPushAttrib(GL_CULL_FACE|GL_LIGHT0|GL_LIGHTING|GL_DEPTH_TEST );
        //glPopAttrib();

        glColor3d(1.0, 0.5, 0.2);

        // animation: rotate the scene (not the camera) by using global time as angle:
        // thus light and camera stay in the same place 
        {
            const float cycletime=10.0; // approx. sec for a full cycle
            const float angleM = fmodf( float(2.0*360.0/cycletime*OpenGLCanvasBase::time), 2.0*360.0);
            if (angleM<=360.0){
                glRotatef( angleM,       0.0, 1.0, 0.0 );
            } else {
                glRotatef( angleM-360.0, 1.0, 0.0, 0.0 );
            }
        }

#if 1
        if(glIsList(dplist) == GL_TRUE) 
        {
            glCallList(dplist);
        } else {
            BIASERR("invalid display list dplist="<<dplist);
      BIASBREAK;
        }
#endif // 0/1

        DisplayCoordCross();

#ifdef BIAS_HAVE_FONTGL
        if (font.IsInitialized())
        {
            glColor3f(1.0f, 1.0f, 0.5f);
            font.PrintWinCoords("a0",  0, 0 );
            font.PrintWinCoords("a100x0y",  100, 0 );
            font.PrintWinCoords("a100x50y",  100, 50 ); // OK.

            glColor3f(1.0f, 0.5f, 1.0f);
            font.DrawTextGL::PrintNormCoords("n0", 0.0, 0.0);
            font.DrawTextGL::PrintNormCoords("n0.5x0y", 0.5, 0.0);
            font.DrawTextGL::PrintNormCoords("n0.5x0.25y", 0.5, 0.25);

            GeometryGL::DisplayCoordCrossAxesLabel(1.0, font);
        }
#endif // BIAS_HAVE_FONTGL
    }
}


// --------------------------------------------------------

// 2nd sharing with 1st: 
MyGLCanvas2::MyGLCanvas2(wxFrame* parent)
: 
BIAS::OpenGLCanvas( parent, -1)
,dplist(0)
{}


// ctor with shared context 
MyGLCanvas2::MyGLCanvas2(wxFrame* parent
                         ,wxGLContext* sharedContext
                         ,wxWindowID id 
                         ,const wxPoint& pos 
                         ,const wxSize& size 
                         ,long style
                         ,const wxString& name
                         ,int* attribList 
                         ,const wxPalette& palette )
                         : 
BIAS::OpenGLCanvas(parent,sharedContext, id,pos,size,style,name,attribList,palette)
,dplist(0)
{}

void MyGLCanvas2::DisplayCalls()
{
    CHECK_GL_ERROR; 
    DisplayClear();
    DisplayCameraView();
    //OpenGLCanvas::DisplayCalls();

    if(glIsList(dplist) == GL_TRUE) 
    {
        {
            const float cycletime=3.0; // approx. sec for a full cycle
            const float angleM = fmodf( float(2.0*360.0/cycletime*OpenGLCanvasBase::time), 2.0*360.0);
            if (angleM<=360.0){
                glRotatef( -angleM,       0.0, 1.0, 0.0 );
            } else {
                glRotatef( -(angleM-360.0), 1.0, 0.0, 0.0 );
            }
        }

        glCallList(dplist);
    } else {
        BIASERR("dplist invalid");
    BIASBREAK;
    }

    GeometryGL::DisplayCoordCross(1.5,3.0);

    CHECK_GL_ERROR; 
}


// --------------------------------------------------------

bool ExampleGLSharedApp::OnInit()
{
    // utility: create a Redirection console for cout, cerr etc.
    ConsoleRedirectIO();
    // testing output: 
    cout<<"Hello cout"<<endl;
    cout<<"Hello cerr"<<endl;

    MyFrame *frame = new MyFrame( wxT("ExampleOpenGLCanvas"), wxPoint(0,0), wxSize(640,480) );
    frame->Show(TRUE);
    SetTopWindow(frame);

    return TRUE;
}


// --------------------------------------------------------
BEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_MENU(ID_QUIT, MyFrame::OnQuit)
EVT_MENU(ID_ABOUT, MyFrame::OnAbout)
END_EVENT_TABLE()
// --------------------------------------------------------


MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
: wxFrame((wxFrame *)NULL, -1, title, pos, size)
,p_canvas(NULL)
,p_2nd_canvas(NULL)
{
    // Create a simple top Menu
    wxMenu *menuFile = new wxMenu;  
    menuFile->Append( ID_ABOUT, wxT("&About...") );
    menuFile->AppendSeparator();
    menuFile->Append( ID_QUIT, wxT("E&xit") );
    wxMenuBar *menuBar = new wxMenuBar;
    menuBar->Append(menuFile, wxT("&File"));
    SetMenuBar(menuBar);

    // Create a simple bottom status bar 
    CreateStatusBar(1);

    // Canvas to test: 
    p_canvas=new MyGLCanvas(this);

    // share the context: 
    if ( p_canvas->GetContext() == NULL)
    {
    BIASERR("context of p_canvas is NULL."<<endl
      <<"This means sharing OpenGL contexts may not be supported."<<endl
      <<"Could not share context. aborting");
    BIASBREAK;
    exit(-1);
  }
    p_2nd_canvas = new MyGLCanvas2(this, p_canvas->GetContext(), -1);
    // distribuet the id of the dplist:
    p_2nd_canvas->dplist = 1; // HACK there is only one dplist 


    // put them into sizers: 
    wxBoxSizer * sizer = new wxBoxSizer(wxHORIZONTAL);
    sizer->Add( p_canvas ,1,wxEXPAND|wxALL);
#if wxCHECK_VERSION(2, 6, 2)
    sizer->AddSpacer(4); // available in 2.6.2 but not 2.4.2 (JW)
#endif
    sizer->Add( p_2nd_canvas ,1,wxEXPAND|wxALL);

    // limit min. size:
    sizer->SetItemMinSize(p_canvas, 500,400);
    sizer->SetItemMinSize(p_2nd_canvas, 300,200);
    sizer->SetSizeHints(this);

    // set sizer and triggers Layout()
    SetSizerAndFit(sizer);
}


void MyFrame::OnQuit(wxCommandEvent& ){ 
    Close(TRUE); 
}


void MyFrame::OnAbout(wxCommandEvent& )
{
    wxString title(wxT("About"));
    wxString msg; // message
    msg<<wxT("About - ")<<AsciiToWx(FUNCNAME)<<wxT("\n");
    msg<<wxT("author: Jan Woetzel (c) 2003-2005\n");
    msg<<wxT("build: ")<<AsciiToWx(__DATE__)<<wxT(" ")<<AsciiToWx(__TIME__)<<wxT("\n");
    msg<<wxT("from ")<<AsciiToWx(__FILE__)<<wxT("\n");
    msg<<wxT("GUI using: ")<<wxVERSION_STRING<<wxT("\n");
    msg<<wxT("\n");
    COUT(msg);
    wxMessageBox(msg, title, wxICON_INFORMATION | wxOK );
}