441 lines
12 KiB
C++
441 lines
12 KiB
C++
#include <cstdio>
|
||
#include <cstdlib>
|
||
#include <iostream>
|
||
#include <list>
|
||
#include <string>
|
||
#include <fstream>
|
||
#include <sstream>
|
||
|
||
#include <osg/Geode>
|
||
#include <osg/ShapeDrawable>
|
||
#include <osg/Material>
|
||
#include <osg/Texture2D>
|
||
#include <osg/Geometry>
|
||
#include <osg/MatrixTransform>
|
||
#include <osg/PositionAttitudeTransform>
|
||
#include <osg/BlendFunc>
|
||
#include <osg/ClearNode>
|
||
#include <osg/Depth>
|
||
#include <osg/Projection>
|
||
|
||
#include <osgUtil/Tesselator>
|
||
#include <osgUtil/TransformCallback>
|
||
#include <osgUtil/CullVisitor>
|
||
#include <osgUtil/Optimizer>
|
||
|
||
#include <osgText/Text>
|
||
|
||
#include <osgGA/TrackballManipulator>
|
||
|
||
#include <osgProducer/Viewer>
|
||
|
||
#include <osgDB/ReadFile>
|
||
|
||
int runApp(std::string xapp);
|
||
|
||
// class to handle events with a pick
|
||
class PickHandler : public osgGA::GUIEventHandler {
|
||
public:
|
||
|
||
PickHandler(osgProducer::Viewer* viewer,osgText::Text* updateText):
|
||
_viewer(viewer),
|
||
_updateText(updateText) {}
|
||
|
||
~PickHandler() {}
|
||
|
||
bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& us);
|
||
|
||
std::string pick(float x, float y);
|
||
|
||
void highlight(const std::string& name)
|
||
{
|
||
if (_updateText.get()) _updateText->setText(name);
|
||
}
|
||
|
||
protected:
|
||
|
||
osgProducer::Viewer* _viewer;
|
||
osg::ref_ptr<osgText::Text> _updateText;
|
||
};
|
||
|
||
bool PickHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter&)
|
||
{
|
||
switch(ea.getEventType())
|
||
{
|
||
case(osgGA::GUIEventAdapter::FRAME):
|
||
case(osgGA::GUIEventAdapter::MOVE):
|
||
{
|
||
osg::notify(osg::NOTICE)<<"MOVE "<<ea.getX()<<ea.getY()<<std::endl;
|
||
std::string picked_name = pick(ea.getX(),ea.getY());
|
||
highlight(picked_name);
|
||
return false;
|
||
}
|
||
case(osgGA::GUIEventAdapter::PUSH):
|
||
{
|
||
osg::notify(osg::NOTICE)<<"PUSH "<<ea.getX()<<ea.getY()<<std::endl;
|
||
std::string picked_name = pick(ea.getX(),ea.getY());
|
||
if (!picked_name.empty())
|
||
{
|
||
runApp(picked_name);
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
|
||
|
||
std::string PickHandler::pick(float x, float y)
|
||
{
|
||
osgUtil::IntersectVisitor::HitList hlist;
|
||
if (_viewer->computeIntersections(x, y, hlist))
|
||
{
|
||
for(osgUtil::IntersectVisitor::HitList::iterator hitr=hlist.begin();
|
||
hitr!=hlist.end();
|
||
++hitr)
|
||
{
|
||
if (hitr->_geode.valid() && !hitr->_geode->getName().empty()) return hitr->_geode->getName();
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
|
||
osg::Node* createHUD(osgText::Text* updateText)
|
||
{ // create the hud. derived from osgHud.cpp
|
||
// adds a set of quads, each in a separate Geode - which can be picked individually
|
||
// eg to be used as a menuing/help system!
|
||
// Can pick texts too!
|
||
osg::MatrixTransform* modelview_abs = new osg::MatrixTransform;
|
||
modelview_abs->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
|
||
modelview_abs->setMatrix(osg::Matrix::identity());
|
||
|
||
osg::Projection* projection = new osg::Projection;
|
||
projection->setMatrix(osg::Matrix::ortho2D(0,1280,0,1024));
|
||
projection->addChild(modelview_abs);
|
||
|
||
|
||
std::string timesFont("fonts/times.ttf");
|
||
|
||
// turn lighting off for the text and disable depth test to ensure its always ontop.
|
||
osg::Vec3 position(150.0f,700.0f,0.0f);
|
||
osg::Vec3 delta(0.0f,-60.0f,0.0f);
|
||
|
||
{ // this displays what has been selected
|
||
osg::Geode* geode = new osg::Geode();
|
||
osg::StateSet* stateset = geode->getOrCreateStateSet();
|
||
stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
|
||
stateset->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
|
||
geode->setName("The text label");
|
||
geode->addDrawable( updateText );
|
||
modelview_abs->addChild(geode);
|
||
|
||
updateText->setCharacterSize(20.0f);
|
||
updateText->setFont(timesFont);
|
||
updateText->setColor(osg::Vec4(1.0f,1.0f,0.0f,1.0f));
|
||
updateText->setText("");
|
||
updateText->setPosition(position);
|
||
|
||
position += delta;
|
||
}
|
||
|
||
return projection;
|
||
|
||
} // end create HUDf
|
||
|
||
|
||
|
||
|
||
static osg::Vec3 defaultPos( 0.0f, 0.0f, 0.0f );
|
||
static osg::Vec3 centerScope(0.0f, 0.0f, 0.0f);
|
||
|
||
class Xample
|
||
{
|
||
std::string texture;
|
||
std::string app;
|
||
public:
|
||
Xample(std::string image, std::string prog)
|
||
{
|
||
texture = image;
|
||
app = prog;
|
||
std::cout << "New Xample!" << std::endl;
|
||
};
|
||
~Xample() { };
|
||
|
||
std::string getTexture()
|
||
{
|
||
return texture;
|
||
}
|
||
std::string getApp()
|
||
{
|
||
return app;
|
||
}
|
||
}; // end class Xample
|
||
|
||
|
||
typedef std::list<Xample>::iterator OP;
|
||
static std::list<Xample> Xamplelist;
|
||
|
||
|
||
void printList()
|
||
{
|
||
std::cout << "start printList()" << std::endl;
|
||
for (OP i = Xamplelist.begin() ; i != Xamplelist.end() ; ++i)
|
||
{
|
||
Xample& x = *i;
|
||
std::cout << "current x.texture = " << x.getTexture() << std::endl;
|
||
std::cout << "current x.app = " << x.getApp() << std::endl;
|
||
}
|
||
std::cout << "end printList()" << std::endl;
|
||
} // end printList()
|
||
|
||
|
||
int runApp(std::string xapp)
|
||
{
|
||
std::cout << "start runApp()" << std::endl;
|
||
for (OP i = Xamplelist.begin() ; i != Xamplelist.end() ; ++i)
|
||
{
|
||
Xample& x = *i;
|
||
if(!xapp.compare(x.getApp()))
|
||
{
|
||
std::cout << "app found!" << std::endl;
|
||
|
||
const char* cxapp = xapp.c_str();
|
||
|
||
std::cout << "char* = " << cxapp <<std::endl;
|
||
|
||
system(cxapp);
|
||
return 1;
|
||
}
|
||
}
|
||
std::cout << "app not found!" << std::endl;
|
||
return 0;
|
||
} // end printList()
|
||
|
||
|
||
void readConfFile(char* confFile) // read confFile 1
|
||
{
|
||
std::cout << "Start reading confFile" << std::endl;
|
||
|
||
std::ifstream in(confFile);
|
||
if (!in)
|
||
{
|
||
std::cout << "File " << confFile << " can not be opened!" << std::endl;
|
||
exit(1);
|
||
}
|
||
std::string imageBuffer;
|
||
std::string appBuffer;
|
||
|
||
while (!in.eof())
|
||
{
|
||
getline(in, imageBuffer);
|
||
getline(in, appBuffer);
|
||
if(imageBuffer == "" || appBuffer == "");
|
||
else
|
||
{
|
||
std::cout << "imageBuffer: " << imageBuffer << std::endl;
|
||
std::cout << "appBuffer: " << appBuffer << std::endl;
|
||
// jeweils checken ob image vorhanden ist.
|
||
|
||
Xample tmp(imageBuffer, appBuffer); // create Xample objects 2
|
||
|
||
Xamplelist.push_back(tmp); // store objects in list 2
|
||
|
||
}
|
||
}
|
||
|
||
in.close();
|
||
|
||
std::cout << "End reading confFile" << std::endl;
|
||
|
||
printList();
|
||
} // end readConfFile
|
||
|
||
|
||
void SetObjectTextureState(osg::Geode *geodeCurrent, std::string texture)
|
||
{
|
||
// retrieve or create a StateSet
|
||
osg::StateSet* stateTexture = geodeCurrent->getOrCreateStateSet();
|
||
|
||
// load texture.jpg as an image
|
||
osg::Image* imgTexture = osgDB::readImageFile( texture );
|
||
|
||
// if the image is successfully loaded
|
||
if (imgTexture)
|
||
{
|
||
// create a new two-dimensional texture object
|
||
osg::Texture2D* texCube = new osg::Texture2D;
|
||
|
||
// set the texture to the loaded image
|
||
texCube->setImage(imgTexture);
|
||
|
||
// set the texture to the state
|
||
stateTexture->setTextureAttributeAndModes(0,texCube,osg::StateAttribute::ON);
|
||
|
||
// set the state of the current geode
|
||
geodeCurrent->setStateSet(stateTexture);
|
||
}
|
||
} // end SetObjectTextureState
|
||
|
||
|
||
osg::Geode* createTexturedCube(float fRadius,osg::Vec3 vPosition, std::string texture, std::string geodeName)
|
||
{
|
||
// create a cube shape
|
||
osg::Box *bCube = new osg::Box(vPosition,fRadius);
|
||
// osg::Box *bCube = new osg::Box(vPosition,fRadius);
|
||
|
||
// create a container that makes the cube drawable
|
||
osg::ShapeDrawable *sdCube = new osg::ShapeDrawable(bCube);
|
||
|
||
// create a geode object to as a container for our drawable cube object
|
||
osg::Geode* geodeCube = new osg::Geode();
|
||
geodeCube->setName( geodeName );
|
||
|
||
// set the object texture state
|
||
SetObjectTextureState(geodeCube, texture);
|
||
|
||
// add our drawable cube to the geode container
|
||
geodeCube->addDrawable(sdCube);
|
||
|
||
return(geodeCube);
|
||
} // end CreateCube
|
||
|
||
|
||
osg::PositionAttitudeTransform* getPATransformation(osg::Node* object, osg::Vec3 position, osg::Vec3 scale, osg::Vec3 pivot)
|
||
{
|
||
osg::PositionAttitudeTransform* tmpTrans = new osg::PositionAttitudeTransform();
|
||
tmpTrans->addChild( object );
|
||
|
||
tmpTrans->setPosition( position );
|
||
tmpTrans->setScale( scale );
|
||
tmpTrans->setPivotPoint( pivot );
|
||
|
||
return tmpTrans;
|
||
}
|
||
|
||
void printBoundings(osg::Node* current, std::string name)
|
||
{
|
||
const osg::BoundingSphere& currentBound = current->getBound();
|
||
std::cout << name << std::endl;
|
||
std::cout << "center = " << currentBound.center() << std::endl;
|
||
std::cout << "radius = " << currentBound.radius() << std::endl;
|
||
|
||
// return currentBound.radius();
|
||
}
|
||
|
||
|
||
osg::Group* setupGraph() // create Geodes/Nodes from Xamplelist 3
|
||
{
|
||
osg::Group* xGroup = new osg::Group();
|
||
|
||
|
||
// positioning and sizes
|
||
float defaultRadius = 0.8f;
|
||
|
||
int itemsInLine = 4; // name says everything
|
||
float offset = 0.05f;
|
||
float bs = (defaultRadius / 4) + offset;
|
||
float xstart = (3*bs) * (-1);
|
||
float zstart = xstart * (-1);
|
||
float xnext = xstart;
|
||
float znext = zstart;
|
||
float xjump = (2*bs);
|
||
float zjump = xjump;
|
||
osg::Vec3 vScale( 0.5f, 0.5f, 0.5f );
|
||
osg::Vec3 vPivot( 0.0f, 0.0f, 0.0f );
|
||
// end positioning and sizes
|
||
|
||
// loop to run through Xampleliste
|
||
int z = 1;
|
||
for (OP i = Xamplelist.begin() ; i != Xamplelist.end() ; ++i, ++z)
|
||
{
|
||
Xample& x = *i;
|
||
|
||
osg::Node* tmpCube = createTexturedCube(defaultRadius, defaultPos, x.getTexture(), x.getApp());
|
||
printBoundings(tmpCube, x.getApp());
|
||
osg::Vec3 vPosition( xnext, 0.0f, znext );
|
||
osg::PositionAttitudeTransform* transX = getPATransformation(tmpCube, vPosition, vScale, vPivot);
|
||
xGroup->addChild( transX );
|
||
|
||
// n<>chster punkt um einen cube zu zeichnen
|
||
if(z < itemsInLine)
|
||
xnext += xjump;
|
||
else
|
||
{
|
||
xnext = xstart;
|
||
znext -= zjump;
|
||
z = 1;
|
||
}
|
||
} // end loop to run through list
|
||
|
||
return xGroup;
|
||
} // end setupGraph
|
||
|
||
|
||
int main( int argc, char **argv )
|
||
{
|
||
if (argc<=1)
|
||
{
|
||
std::cout << "Error: First argument missing!" << std::endl << "First argument -> confFile" << std::endl;
|
||
return 0;
|
||
}
|
||
|
||
readConfFile(argv[1]); // read ConfigFile 1
|
||
|
||
// construct the viewer.
|
||
osgProducer::Viewer viewer;
|
||
|
||
// set up the value with sensible default event handlers.
|
||
viewer.setUpViewer(osgProducer::Viewer::STANDARD_SETTINGS);
|
||
|
||
osg::ref_ptr<osgText::Text> updateText = new osgText::Text;
|
||
|
||
// add the handler for doing the picking
|
||
viewer.getEventHandlerList().push_front(new PickHandler(&viewer,updateText.get()));
|
||
|
||
osg::Group* root = new osg::Group();
|
||
|
||
root->addChild( setupGraph() );
|
||
|
||
// add the HUD subgraph.
|
||
root->addChild(createHUD(updateText.get()));
|
||
|
||
// add model to viewer.
|
||
viewer.setSceneData( root );
|
||
|
||
// create the windows and run the threads.
|
||
viewer.realize();
|
||
|
||
osg::Matrix lookAt;
|
||
lookAt.makeLookAt(osg::Vec3(0.0f, -4.0f, 0.0f), centerScope, osg::Vec3(0.0f, 0.0f, 1.0f));
|
||
|
||
// viewer.setView(lookAt);
|
||
|
||
while( !viewer.done() )
|
||
{
|
||
// wait for all cull and draw threads to complete.
|
||
viewer.sync();
|
||
|
||
// update the scene by traversing it with the the update visitor which will
|
||
// call all node update callbacks and animations.
|
||
viewer.update();
|
||
|
||
// to be able to turn scene, place next call before viewer.update()
|
||
// viewer.setView(lookAt);
|
||
|
||
|
||
// fire off the cull and draw traversals of the scene.
|
||
viewer.frame();
|
||
|
||
}
|
||
|
||
// wait for all cull and draw threads to complete before exit.
|
||
viewer.sync();
|
||
|
||
return 0;
|
||
} // end main
|