da/d52/ExampleGLShared_8cpp-example.html

/* 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 );

}