ScenePlainOpenSceneGraph.cpp

#include <GLviewer/Scenes/SceneBase.hh>
#include <Base/Common/FileHandling.hh>
#include "ScenePlainOpenSceneGraph.hh"
#include <osg/MatrixTransform>
#include <osgShadow/ShadowedScene>
#include <osg/Depth>
#include <cctype>

using namespace std;
using namespace BIAS;

ScenePlainOpenSceneGraph::ScenePlainOpenSceneGraph() : SceneBase()
{
  initialized_ = false;
}

int ScenePlainOpenSceneGraph::Init(unsigned int width, unsigned int height)
{
    if (initialized_) {
        BIASERR("Init on SceneOpenSceneGraph should only be called once: skipping\n");
        return 0;
    }

  w_ = width;
  h_ = height;
  sceneView_ = new osgViewer::Viewer;
  sceneView_->setThreadingModel(osgViewer::Viewer::SingleThreaded);
  embedWindow_ = sceneView_->setUpViewerAsEmbeddedInWindow(0, 0, w_, h_);
  sceneView_->getCamera()->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
  sceneView_->getCamera()->setClearMask(0);
  //sceneView_->setLightingMode(osg::View::NO_LIGHT);
  rootNode_ = new osg::Group;
  sceneView_->setSceneData(rootNode_.get());
  sceneView_->realize();
  initialized_ = true;
  return 0;
}

void ScenePlainOpenSceneGraph::SetLighting(bool on) {
  if (on){
    rootNode_->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::ON);
  }
  else{
    rootNode_->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
  }
}

ScenePlainOpenSceneGraph::~ScenePlainOpenSceneGraph()
{
  if (initialized_) {
    initialized_ = false;
    // todo this is a workaround for on exit crash in glutglviewer fkellner
    sceneView_.release();
    sceneView_ = NULL;
    rootNode_ = NULL;
  }
}

bool ScenePlainOpenSceneGraph::Load(std::string filename) {
  osg::ref_ptr<osg::Node> node;
  node = osgDB::readNodeFile(filename);
  if (node.get()) {
    rootNode_->addChild(node.get());
    rootNode_->dirtyBound();
    return true;
  }
  else
    return false;
}


int ScenePlainOpenSceneGraph::AppendSubTreeFromFile(const std::string& fileName, osg::ref_ptr<osg::Node>& node) {
  node = osgDB::readNodeFile(fileName);
  string path, base, suffix;
  BIAS::FileHandling::SplitName(fileName, path, base, suffix);
  std::transform(suffix.begin(), suffix.end(), suffix.begin(), (int
  (*)(int)) std::tolower);
  if (suffix == ".wrl") {
    // osg wrl import automatically adds a transform node (rotation around
    // x-axis). This needs to be dropped
    osg::MatrixTransform *mt =
        dynamic_cast<osg::MatrixTransform *> (node.get());
    if (mt && mt->getNumChildren() == 1) {
      node = mt->getChild(0);
    }
  }
  rootNode_->addChild(node.get());
  rootNode_->dirtyBound();
  return 0;
}

int ScenePlainOpenSceneGraph::AppendSubTreeFromFile(const std::string& fileName) {
  osg::ref_ptr<osg::Node> node;
  AppendSubTreeFromFile(fileName, node);
  return 0;
}

void ScenePlainOpenSceneGraph::AppendNode(osg::ref_ptr<osg::Node> node) {
  rootNode_->addChild(node.get());
  rootNode_->dirtyBound();
}
void ScenePlainOpenSceneGraph::RemoveNode(osg::ref_ptr<osg::Node> node){
    
    rootNode_->removeChild(node.get());
  rootNode_->dirtyBound();
}

void ScenePlainOpenSceneGraph::Clear(){
    int children = rootNode_->getNumChildren();
    rootNode_->removeChild(0,children);
  rootNode_->dirtyBound();
}


void ScenePlainOpenSceneGraph::SetRootNode(osg::ref_ptr<osg::Group> newRoot) {
  rootNode_ = newRoot;
  sceneView_->setSceneData(rootNode_.get());
}

void ScenePlainOpenSceneGraph::Draw()
{

  GLint viewParams[4];
  glGetIntegerv( GL_VIEWPORT, viewParams );
  if (w_ != (unsigned int)(viewParams[2]) || h_ != (unsigned int)(viewParams[3])) {
    w_ = (unsigned int)viewParams[2];
    h_ = (unsigned int)viewParams[3];
    embedWindow_->resized(embedWindow_->getTraits()->x, embedWindow_->getTraits()->y, w_, h_);
    embedWindow_->getEventQueue()->windowResize(embedWindow_->getTraits()->x, embedWindow_->getTraits()->y, w_, h_ );
  }

  GLfloat glMat[16];
  osg::Matrixf osgMat;

  glGetFloatv( GL_PROJECTION_MATRIX, glMat );
  osgMat.set( glMat );
  sceneView_->getCamera()->setProjectionMatrix( osgMat );

  glGetFloatv( GL_MODELVIEW_MATRIX, glMat );
  osgMat.set( glMat );
  sceneView_->getCamera()->getViewMatrix().set( osgMat );

  glPushAttrib( GL_VIEWPORT_BIT );
  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glMatrixMode(GL_TEXTURE);
  glPushMatrix();
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  if (sceneView_.valid())
    sceneView_->frame();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
  glMatrixMode(GL_TEXTURE);
  glPopMatrix();
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glPopAttrib(); // GL_VIEWPORT_BIT
}


void ScenePlainOpenSceneGraph::GetBoundingBox(BIAS::Vector3<double> &themin, BIAS::Vector3<double> &themax)
{
  const osg::BoundingSphere& bs = rootNode_->getBound();

  BIAS::Vector3<double> center((double) bs.center()[0], (double) bs.center()[1],
      (double) bs.center()[2]);

  double radius = (double) bs.radius();

  BIAS::Vector3<double> diag(radius, radius, radius);
  themin = center - diag;
  themax = center + diag;
}

Vector3<double>
ScenePlainOpenSceneGraph::GetBoundingBoxCenter()
{
  const osg::BoundingSphere& bs = rootNode_->getBound();

  return BIAS::Vector3<double>((double) bs.center()[0],
      (double) bs.center()[1], (double) bs.center()[2]);
}