src/UserInterface.cpp

Go to the documentation of this file.

/*

Traplas visualisation.

Copyright (C) 2006 Herbert de Vos & Willem Drost

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

*/


//osg headers for nodes, etc
//

#ifndef STATECONTROL_H
#include "StateControl.h"
#endif

#ifndef USERINTERFACE_H
#include "UserInterface.h"
#endif

#ifndef GLOBALS_H
#include "Globals.h"
#endif

#ifndef _GLIBCXX_SSTREAM
#include <sstream>
#endif

#ifndef _GLIBCXX_IOMANIP
#include <iomanip> //for setting string stream precision.
#endif

UserEventHandler::UserEventHandler(osgProducer::Viewer* viewer, UserInterface* ui){
        _viewer = viewer;
        _user = ui;
}

bool UserEventHandler::handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& us)
{
        switch(ea.getEventType())
        {
                case(osgGA::GUIEventAdapter::PUSH):
                {
                        pick(ea);
                }
                case(osgGA::GUIEventAdapter::KEYDOWN):
                {
                        if( ea.getKey() == 'p' )
                                _user->s->pause();      
                }
                case(osgGA::GUIEventAdapter::FRAME):
                {
                        _user->updateClock();
                        //if we want to do anything with the camera through updating the matrix, this is the place. OTOH, right now we're trying tot add the camera directly to a node through osgGA::NodeTrackerManipulator.   
                }
                return false;
                default:
                return false;
        }
}

//Alternative pick: Middle mouse button now selects.
void UserEventHandler::pick(const osgGA::GUIEventAdapter& ea)
{
  osgUtil::IntersectVisitor::HitList hlist;

  if (_viewer->computeIntersections(ea.getX(),ea.getY(),hlist))
  {
    for(osgUtil::IntersectVisitor::HitList::iterator hitr=hlist.begin(); hitr!=hlist.end(); ++hitr)
    {
      if (hitr->_geode.valid() && !hitr->_geode->getName().empty())
      {
        // the geodes are identified by name.
        unsigned int mouseButtonAction = ea.getButtonMask();
        if(mouseButtonAction == osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON)
        {
          _user->buttonAction(hitr->_geode->getParent(0)->getParent(0)->getName());
          if( (hitr->_geode->getParent(0)->getName() == "" ) && ( hitr->_geode->getParent(0)->getParent(0)->getName() == "" ) )
          {
             _user->buttonAction(hitr->_geode->getName());
          }
                                }
                                else if(mouseButtonAction == osgGA::GUIEventAdapter::MIDDLE_MOUSE_BUTTON)
          {
            osg::Group* pickedModel = dynamic_cast<osg::Group*>(hitr->_geode->getParent(0)->getParent(0));
            assert(pickedModel != NULL);
            
                                                _user->selectionAction(pickedModel);
          }
      }
      break;  //  Only process the first hit.
    }
  }
}


UserInterface::UserInterface(StateControl* st){
        s = st;
        hud=NULL;
        hudCam = NULL;
        clock = NULL;
}


osg::Node* UserInterface::createHud(){

        osg::Geode* HUDGeode = new osg::Geode();
        hud = HUDGeode;
        //Set up the hud itself:

        HUDGeode->setName("HUD");
        // Set up geometry for the HUD and add it to the HUD
        osg::Geometry* HUDBackgroundGeometry = new osg::Geometry();
        osg::Vec3Array* HUDBackgroundVertices = new osg::Vec3Array;
        HUDBackgroundVertices->push_back( osg::Vec3( 0,    0,-1) );
        HUDBackgroundVertices->push_back( osg::Vec3(1280,  0,-1) );
        HUDBackgroundVertices->push_back( osg::Vec3(1280,200,-1) );
        HUDBackgroundVertices->push_back( osg::Vec3(   0,200,-1) );
        osg::DrawElementsUInt* HUDBackgroundIndices =
        new osg::DrawElementsUInt(osg::PrimitiveSet::POLYGON, 0);
        HUDBackgroundIndices->push_back(0);
        HUDBackgroundIndices->push_back(1);
        HUDBackgroundIndices->push_back(2);
        HUDBackgroundIndices->push_back(3);
        osg::Vec4Array* HUDcolors = new osg::Vec4Array;
        HUDcolors->push_back(osg::Vec4(0.8f,0.8f,0.8f,0.1f));

        osg::Vec2Array* texcoords = new osg::Vec2Array(4);
        (*texcoords)[0].set(0.0f,0.0f);
        (*texcoords)[1].set(1.0f,0.0f);
        (*texcoords)[2].set(1.0f,1.0f);
        (*texcoords)[3].set(0.0f,1.0f);
        HUDBackgroundGeometry->setTexCoordArray(0,texcoords);

        osg::Vec3Array* HUDnormals = new osg::Vec3Array;
        HUDnormals->push_back(osg::Vec3(0.0f,0.0f,1.0f));
        HUDBackgroundGeometry->setNormalArray(HUDnormals);
        HUDBackgroundGeometry->setNormalBinding(osg::Geometry::BIND_OVERALL);
        HUDBackgroundGeometry->addPrimitiveSet(HUDBackgroundIndices);
        HUDBackgroundGeometry->setVertexArray(HUDBackgroundVertices);
        HUDBackgroundGeometry->setColorArray(HUDcolors);
        HUDBackgroundGeometry->setColorBinding(osg::Geometry::BIND_OVERALL);

        HUDGeode->addDrawable(HUDBackgroundGeometry);

        osg::StateSet* HUDStateSet = new osg::StateSet();
        HUDGeode->setStateSet(HUDStateSet);

        //enable blending 
        HUDStateSet->setMode(GL_BLEND,osg::StateAttribute::ON);

        // Disable lighting.
        HUDStateSet->setMode(GL_LIGHTING,osg::StateAttribute::OFF);     
        
        // Disable depth testing so geometry is draw regardless of depth values
        // of geometry already draw.
        HUDStateSet->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
        HUDStateSet->setRenderingHint( osg::StateSet::TRANSPARENT_BIN );

        osg::Projection* projection = new osg::Projection;
        projection->setMatrix(osg::Matrix::ortho2D(0,1280,0,1024));

  //  Add a CameraNode to allow picking in the hud.
        osg::CameraNode* myview = new osg::CameraNode();
        hudCam = myview;
        myview->setProjectionMatrix(projection->getMatrix());
        myview->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
        myview->setClearMask(GL_DEPTH_BUFFER_BIT);
        projection->addChild(myview);
        
        osg::AutoTransform* pos = createHUDObject("Quit",true, 100, 40);
        myview->addChild(pos);
        
        pos = createHUDObject("Pause", true, 180, 40);
        myview->addChild(pos);

        pos = createHUDObject("-", true, 260, 40);
        myview->addChild(pos);
        
        pos = createHUDObject("+", true, 300, 40);
        myview->addChild(pos);


/*TODO part of following selected objects.
        pos = createHUDObject("Follow", true, 380, 40);
        myview->addChild(pos);
*/
        //add clock:
        ostringstream os;
  os << "Time: "<< showpoint << s->getTime() << "\n Timeflow:" << s->getTimeFlow();
        string currentTime = os.str();  
        pos = createHUDObject(currentTime , false, 1000,190);
        myview->addChild(pos);

        //get a reference to the clock for updating.
        osg::Geode* tmpG = dynamic_cast<osg::Geode*>(pos->getChild(0));
        assert(tmpG != NULL);

        clock = dynamic_cast<osgText::Text*>(tmpG->getDrawable(0));
        assert(clock != NULL);

        return projection;
}

osg::AutoTransform* UserInterface::createHUDObject(string text, bool pickable, int xpos, int ypos){

                osg::Geode* object = new osg::Geode();
                if(pickable){
                        object->setName(text);
                }

                //label:
                osgText::Text* objectText = new osgText::Text();
                objectText->setCharacterSize(FONTSIZE_HUD);
        //      objectText->setAxisAlignment(osgText::Text::SCREEN);
                objectText->setDrawMode(osgText::Text::TEXT | osgText::Text::ALIGNMENT | osgText::Text::CENTER_TOP);
                objectText->setAlignment(osgText::Text::CENTER_TOP);
                objectText->setText(text);
                objectText->setColor(osg::Vec4d(1.0f, 0.0f, 0.0f, 1.0f) );
                object->addDrawable(objectText);

                osg::StateSet* s = new osg::StateSet();
                // For this state set, turn blending on (so alpha texture looks right)
                s->setMode(GL_BLEND,osg::StateAttribute::ON);           
                // Disable lighting.
                s->setMode(GL_LIGHTING,osg::StateAttribute::OFF);       
                // Disable depth testing so geometry is draw regardless of depth values
                // of geometry already draw.
                s->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
                s->setRenderingHint( osg::StateSet::TRANSPARENT_BIN );
                object->setStateSet(s);                                         
                
                //      Add some sort of plane or shape to the Geode to allow easy picking.
                osg::BoundingBox bb;
                for( unsigned int i=0 ; i < object->getNumDrawables() ; ++i )
        {
            bb.expandBy( object->getDrawable(i)->getBound() );
        } 
        osg::Box *box = new osg::Box(   osg::Vec3( (bb.xMax() + bb.xMin()) / 2 , (bb.yMax() + bb.yMin()) / 2 , 0 ) , 
                                                                                bb.xMax() - bb.xMin() , 
                                                                        bb.yMax() - bb.yMin() , 
                                                                        0 );
                osg::ShapeDrawable *sd = new osg::ShapeDrawable( box , 0 );
                sd->setColor(osg::Vec4d(1.0f, 1.0f, 1.0f, 0.0f) );
                object->addDrawable( sd );


                //positioning:
                osg::AutoTransform* objPos = new osg::AutoTransform();
                objPos->setPosition(osg::Vec3d(xpos, ypos, 0));
                objPos->addChild(object);

                return objPos;
}

void UserInterface::setHUDText(string t){
        hudCam->addChild( createHUDObject(t, false, 150,190) ); //Right now text is not positioned. A second text will appear on top of the 1st one.

}

void UserInterface::rmHUDText(string rt)
{
        int numChildren = hudCam->getNumChildren();
        for(int ind = (numChildren -1); ind >= 0; ind--){
                //for debugging:
                osg::AutoTransform* ta = dynamic_cast<osg::AutoTransform*> (hudCam->getChild(ind));
                        assert(ta != NULL);
                osg::Geode* tg = dynamic_cast<osg::Geode*>(ta->getChild(0));
                        assert(tg != NULL);
                osgText::Text* td = dynamic_cast<osgText::Text*>(tg->getDrawable(0));
                        assert(td != NULL);
                //WARNING: If the description is not uniquq, this won't work.
                string hudTxt = td->getText().createUTF8EncodedString();
                if(hudTxt.substr(0, hudTxt.find_first_of('\n')) == rt.substr(0,rt.find_first_of('\n'))){
                        hudCam->removeChild(ind);
                        return; //only remove the first instance that matches.
                }
        }
 
}


bool UserInterface::buttonAction(string buttonName){
        if(!strcmp(buttonName.c_str(), "Quit")){
                cout << "Quit button pushed, Exit." << endl;
                exit(0);
        }
        if(!strcmp(buttonName.c_str(), "+")){
                s->adjustTimeFlow(0.5);
        }else
        if(!strcmp(buttonName.c_str(), "-")){
                s->adjustTimeFlow(-0.5);
        }else
        if(!strcmp(buttonName.c_str(), "Pause")){
                s->pause();
        }
        /*TODO camera tracking of a selected object.
        else
        if(!strcmp(buttonName.c_str(), "Follow")){
                s->track();
        }
        */
        return true;

}

bool UserInterface::selectionAction(osg::Node* selected){
        
        TraplasObject* tra = dynamic_cast<TraplasObject*> (selected->getUserData());
        if(tra == NULL){ 
                cout << "Not a TraplasObject" << endl;
                return false;
        }
        
        if(tra->isSelected()){
                 s->deselectObject(tra);
        }else{
                s->clearSelection();
                s->selectObject(tra);           
        }
        
        return true;
}

void UserInterface::updateClock(){
        ostringstream os;
        os << "Time: "<< showpoint << s->getTime() << "\n Timeflow:" << showpoint <<s->getTimeFlow();
  string currentTime = os.str();
        clock->setText(currentTime);
}

---