SceneOpenSceneGraph.cpp

#include <bias_config.h>
#include <Gui/biasgl.h>

#include "SceneOpenSceneGraph.hh"
#include <GLviewer/OpenSceneGraphHelper.hh>

#include <GLviewer/GLProjectionParametersInterface.hh>
#include <Base/Common/FileHandling.hh>
#include <Base/Debug/Debug.hh>
#include <osg/CameraNode>
#include <osg/Depth>
#include <osg/Geometry>
#include <osg/BlendEquation>
#include <osg/CullFace>
#include <osg/FrontFace>
#include <osg/LightSource>
#include <osg/Switch>
#include <osg/Stencil>
#include <osg/MatrixTransform>
#include <osg/BlendFunc>
#include <osgShadow/ShadowedScene>
#include <osgShadow/ShadowMap>
#include <osg/Version>

//------ for osg animation ----
//#include <osgAnimation/>

// ----- for mirror --------
#include <osg/AlphaFunc>
#include <osg/Node>
#include <osg/Geometry>
#include <osg/Geode>
#include <osg/Notify>
#include <osg/ClipNode>
#include <osg/AnimationPath>
#include <osgDB/ReadFile>
#include <osgDB/WriteFile>
#include <osgUtil/Optimizer>
#include <osgViewer/Viewer>
#include <iostream>
// ------- for particles -------
#include <osgParticle/Particle>
#include <osgParticle/ParticleSystem>
#include <osgParticle/ParticleSystemUpdater>
#include <osgParticle/ModularEmitter>
#include <osgParticle/MultiSegmentPlacer>
#include <osgParticle/ModularProgram>
#include <osgParticle/AccelOperator>
#include <osgParticle/FluidFrictionOperator>

// ------- for fx -------------
#include <osgFX/Registry>
#include <osgFX/Effect>
#include <osgFX/BumpMapping>

#include <GLviewer/Scenes/NodeInfoOpenSGVisitor.hh>
#include <osgDB/WriteFile>
#include <cctype>

#ifdef WIN32
# include <direct.h>  // for _getcwd
#endif

using namespace std;
using namespace BIAS;
using namespace BIAS;


//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////


SceneOpenSceneGraph::
SceneOpenSceneGraph(bool redirect) : SceneBase(), timer_(), startTick_()
{
  NewDebugLevel("D_SCENEOSG");
  NewDebugLevel("D_SCENEOSG_MatrixTransform");
  AddDebugLevel("D_SCENEOSG");
  AddDebugLevel("D_SCENEOSG_MatrixTransform");
  Reset();
}


SceneOpenSceneGraph::
~SceneOpenSceneGraph()
{
    if(initialized_)    Reset();
}


void SceneOpenSceneGraph::
Reset()
{
    animate_= false;
    clearMask_  =GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT;
    initialized_ = false;
  sceneView_ = NULL;
  rootTree_ = NULL;
  lightTransform_ = NULL;
  lightRepresentationSwitch_ = NULL;
  lightRepresentationGeode_ = NULL;
  frameStamp_ = NULL;
  frameNumber_ = 0;
  headlight_ = true;
  timeOffset_ =0;
  lastPauseTime_ =0;
  lightRepresentationVisible_ = false;
}


int SceneOpenSceneGraph::
Init()
{
    if (initialized_)
    {
        BIASERR("Init on SceneOpenSceneGraph should only be called "
                "once: skipping\n");
        return 1;
    }

  CreateStandardNodes_();
  initialized_ = true;
  animTime_ = 0.0;
  osg::setNotifyLevel(osg::ALWAYS);//disable osg debugspam
  return 0;
}


void SceneOpenSceneGraph::
CreateStandardNodes_()
{
  // From the FAQ:
  // NOTE: The call to setComputeNearFarMode is very important. If you don't
  // do this, then OSG will use a different near and far plane when rendering
  // its objects, and they will have different values in the depth-buffer than
  // the rest of your scene. This can lead to very odd effects.

  sceneView_ = new osgViewer::Viewer;
  // params of window are overwritten in draw.
  embedWindow_ = sceneView_->setUpViewerAsEmbeddedInWindow(0, 0, 800, 600);
  // clear to black
  sceneView_->getCamera()->setClearColor(osg::Vec4(255.0f, 255.0f, 255.0f, 1.0f));
  sceneView_->getCamera()->setClearMask(clearMask_);
  sceneView_->getCamera()->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
  sceneView_->setLightingMode(osg::View::HEADLIGHT); //NO_LIGHT,HEADLIGHT

  // the Light
  light_= new osg::Light;

  light_->setLightNum( 0 );
  light_->setAmbient( osg::Vec4( .3f, .3f, .3f, 1.0f ));
  //  light_->setAmbient( osg::Vec4(1.0f,1.0f,1.0f,1.0f ));
  light_->setDiffuse( osg::Vec4( 1.0f, 1.0f, 1.0f, 1.0f ));
  light_->setSpecular( osg::Vec4( 1.0f, 1.0f, 1.0f, 1.0f ));

  sceneView_->setLight(light_.get());

  sceneView_->realize();

  rootTree_ = new osg::Group();
  rootTree_ ->setName(SOSG_ROOT_NODE_NAME);
  SetNodeVisible(rootTree_.get(), true);
  sceneView_->setSceneData(rootTree_.get());

  // enable lighting
  osg::StateSet* state = rootTree_->getOrCreateStateSet();
  state->setMode(GL_LIGHTING, osg::StateAttribute::ON);
  state->setMode(GL_LIGHT0, osg::StateAttribute::ON);
  //state->setMode(GL_LIGHTING,osg::StateAttribute::OVERRIDE|osg::StateAttribute::OFF);
  state->setMode(GL_NORMALIZE, osg::StateAttribute::ON); 

  //enable culling
  //state->setMode(GL_CULL_FACE,osg::StateAttribute::ON);
  // ich geb dir gleich "disable culling" !!!
  //state->setMode(GL_CULL_FACE,osg::StateAttribute::OVERRIDE|osg::StateAttribute::OFF);  

  // MatrixTransform
  lightTransform_ = new osg::MatrixTransform;
  osg::Matrix m;
  m.makeTranslate(osg::Vec3(0., 0., 0.));
  lightTransform_->setMatrix(m);
  lightTransform_->setName(SOSG_LIGHT_TRANSFORM_NAME);
  SetNodeVisible(lightTransform_.get(), false);
  rootTree_->addChild(lightTransform_.get());

  // LightSource
  osg::ref_ptr<osg::LightSource> lightSource = new osg::LightSource;
  lightSource->setReferenceFrame(osg::LightSource::ABSOLUTE_RF);
  lightSource->setLight(light_.get());
  lightSource->setName(SOSG_LIGHT_SOURCE_NAME);

  SetNodeVisible(lightSource.get(), false);
  lightTransform_->addChild(lightSource.get());

  // Switch
  lightRepresentationSwitch_ = new osg::Switch;
  lightSource->addChild(lightRepresentationSwitch_.get());
  SetNodeVisible(lightRepresentationSwitch_.get(), false);
  lightRepresentationSwitch_->setName(SOSG_LIGHT_REPRESENTATION_SWITCH_NAME);
  // Geode(Sphere)
  osg::ShapeDrawable *lightRepresentation = new osg::ShapeDrawable(
      new osg::Sphere(osg::Vec3(0., 0., 0.), 20.0));
  lightRepresentation->setColor(osg::Vec4(1., 1., 0., 1.)); // yellow
  lightRepresentationGeode_ = new osg::Geode;
  lightRepresentationGeode_->addDrawable(lightRepresentation);
  lightRepresentationGeode_->setName(SOSG_LIGHT_REPRESENTATION_GEODE_NAME);

  SetNodeVisible(lightRepresentationGeode_.get(), false);
  lightRepresentationSwitch_->addChild(lightRepresentationGeode_.get(),
      lightRepresentationVisible_);

  // enable animations using the frameStamp
  frameStamp_ = new osg::FrameStamp();
  sceneView_->setFrameStamp(frameStamp_.get());
  startTick_ = osg::Timer::instance()->tick();

  //MakeRootShadowNode(lightSource);
  SetFixedPointLight(true,Vector3<double> (10, 10, 10));
}

class disableZwriteNodeVisitor : public osg::NodeVisitor
{
public:
  // Default constructor - initialize searchForName to "" and
  // set the traversal mode to TRAVERSE_ALL_CHILDREN
  disableZwriteNodeVisitor()
    : osg::NodeVisitor(TRAVERSE_ALL_CHILDREN)
  {}
  
  virtual void apply(osg::Geode &node)
  {
    unsigned num_drawables = node.getNumDrawables();
    for (unsigned int i=0; i<num_drawables; i++)
    {
      osg::Drawable* dr = node.getDrawable(i);
      if (dr)
      {
        osg::StateSet* sts = dr->getStateSet();  
        if(sts)
        {
          if(sts->getMode(GL_BLEND)==osg::StateAttribute::ON)
          {            
            osg::Depth* pDepth = new osg::Depth();
            pDepth->setWriteMask(false);
            sts->setAttributeAndModes(pDepth, osg::StateAttribute::OVERRIDE |
                                 osg::StateAttribute::ON);
            sts->setMode(GL_CULL_FACE, osg::StateAttribute::ON |
                        osg::StateAttribute::OVERRIDE );
            osg::CullFace *cullFace = new osg::CullFace(osg::CullFace::BACK);
            sts->setAttribute(cullFace);
            osg::BlendFunc* pBlendFunc = new osg::BlendFunc(osg::BlendFunc::SRC_ALPHA,
                                               osg::BlendFunc::ONE_MINUS_SRC_ALPHA);
            sts->setAttributeAndModes(pBlendFunc, osg::StateAttribute::OVERRIDE |
                                     osg::StateAttribute::ON);
            sts->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
          }
        }
      } 
    }
  }
  virtual void apply(osg::ClearNode &node)
  {
    //cout << "c"<<flush;
    node.setClearMask(0);
  }  
};


void SceneOpenSceneGraph::
DisableZWriteForTransparentNodes_()
{
  //rootTree_
  disableZwriteNodeVisitor vis;
  rootTree_->accept(vis);
}


void SceneOpenSceneGraph::
UpdateLightRepresentation_()
{
  lightRepresentationSwitch_->setChildValue(lightRepresentationGeode_.get(),
      lightRepresentationVisible_);
  //cout << "lightRepresentationVisible: "<<boolalpha<<lightRepresentationVisible_<<endl;
}


void SceneOpenSceneGraph::
AppendSubTree(osg::ref_ptr<osg::Node>& node)
{
  SetNodeOccluder(node.get(),false);
  rootTree_->addChild(node.get());
  rootTree_->dirtyBound();
  
}


int SceneOpenSceneGraph::
AppendSubTreeSwitch(osg::ref_ptr<osg::Node>& node, eNodeType NodeType)
{
  SetNodeOccluder(node.get(),false);
  osg::ref_ptr<osg::Switch> sw = new osg::Switch;
  if ((node->getName()).empty()) {
    sw->setName(SOSG_SWITCH_PREFIX+(string) "Whatever");
  } else {
    sw->setName(SOSG_SWITCH_PREFIX+node->getName());
  }
  SetNodeVisible(sw.get(), false);
  sw->addChild(node.get());
  NodeInfoMap_[node.get()].NodeType = NodeType;
  OpenSceneGraphHelper::AddOrSetInfo(node, SOSG_KEY_NODE_TYPE, 
                                     NodeType2String(NodeType));
  sw->setAllChildrenOn(); //enable rendering of all osg:switch children
 // assigning RenderBin 10 for occluding possibilities
  osg::StateSet *stateset = (node.get())->getOrCreateStateSet();
  stateset->setRenderBinDetails( 10, "RenderBin");
  rootTree_->addChild(sw.get());
  NodeInfoMap_[sw.get()].NodeType = NodeType;
  OpenSceneGraphHelper::AddOrSetInfo(sw, SOSG_KEY_IS_MODEL_SWITCH, 
                                     "TRUE");
  rootTree_->dirtyBound();
  node = sw.get(); // HACK, not very well tested, friso 2009-04  
  SetNodeOccluder(node.get(), false);
  return 0;
}


int SceneOpenSceneGraph::
AppendSubTreeFromFile(const std::string& fileName,
                      osg::ref_ptr<osg::Node>& node,
                      bool optimize)
{
  string path, base, suffix;
  FileHandling::SplitName(fileName, path, base, suffix);
  // hack to work with openvrml 0.14.3 and drive letters c:, d:, ...
#ifdef WIN32
  char currentdir[255];
  if (path!="") {
    _getcwd(currentdir,255);
    int res = _chdir(path.c_str());
    if (res<0) return -1;
  }
    node = osgDB::readNodeFile((base+suffix).c_str());
#else
  node = osgDB::readNodeFile(fileName.c_str());
#endif

#ifdef WIN32
  if (path!="") 
    _chdir(currentdir);
#endif

  if (!node)
    {
        BIASWARN("Could not read 3d-model-file "<<fileName<<endl);
      return -1;
    }

  string name = ((node->getName()).empty()) ? (base) : (node->getName());

  // add a switch node
  osg::ref_ptr<osg::Switch> sw = new osg::Switch;
  sw->setName(SOSG_SWITCH_PREFIX+name);
  OpenSceneGraphHelper::AddOrSetInfo(sw, SOSG_KEY_IS_MODEL_SWITCH, 
                                     "TRUE");
  SetNodeVisible(sw.get(), false);

  std::transform(suffix.begin(), suffix.end(), suffix.begin(), (int
  (*)(int)) std::tolower);
  BCDOUT(D_SCENEOSG_MatrixTransform, "suffix: "<<suffix<< endl);
  if (suffix == ".wrl"){
    BCDOUT(D_SCENEOSG_MatrixTransform, "found wrl file\n");
    // 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){
      osg::Node *child = mt->getChild(0);
      BCDOUT(D_SCENEOSG_MatrixTransform, "dropping matrix transform node\n");
      node = child;
    }
  }
  
  // try to compensate the rotation of the model...
//  osg::ref_ptr<osg::MatrixTransform> mt;
//  if(suffix == ".osg"){
//    BCDOUT(D_SCENEOSG_MatrixTransform, "found wrl file, adding matrix "
//        <<"transform for compensation\n");
//    // osg wrl export automatically adds a transform node (rotation around
//    // x-axis). This needs to be compensated
//    mt = new osg::MatrixTransform(osg::Matrix(1, 0, 0, 0, 0, 0, 1, 0, 0, 1,
//        0, 0, 0, 0, 0, 1));
//    mt->addChild(node);
//    mt->setName(node->getName());
//    node = mt.get();
//  }
  
  //what if no transform node is there? e.g. when loading a 3ds file?
  if(!dynamic_cast<osg::MatrixTransform *>(node.get())){
    osg::MatrixTransform *mt = new osg::MatrixTransform();   
    mt->addChild(node.get());
    node = mt;
  }
  node->setName(name);
  sw->addChild(node.get());

  // assigning RenderBin 10 for occlusion
  osg::StateSet *stateset = (node.get())->getOrCreateStateSet();
  stateset->setMode( GL_RESCALE_NORMAL, osg::StateAttribute::ON );
  stateset->setRenderBinDetails( 10, "RenderBin");
  NodeInfoMap_[node.get()].NodeType = eNT_FromDisk;
  NodeInfoMap_[node.get()].FileName = fileName;
  NodeInfoMap_[node.get()].Name = FileHandling::Basename(fileName);
  NodeInfoMap_[node.get()].IsEditable = true;
  OpenSceneGraphHelper::AddOrSetInfo(node, SOSG_KEY_NODE_TYPE, 
                                     NodeType2String(eNT_FromDisk));
  OpenSceneGraphHelper::AddOrSetInfo(node, SOSG_KEY_FILE_NAME, 
                                     fileName);
  OpenSceneGraphHelper::AddOrSetInfo(node, SOSG_KEY_NAME, 
                                     FileHandling::Basename(fileName) + 
                                     FileHandling::Suffix(fileName));
  OpenSceneGraphHelper::AddOrSetInfo(node, SOSG_KEY_IS_EDITABLE, "TRUE");

  // swap childeNode with Switch node
  node = sw.get();

  AppendSubTree(node);

  // find animation in subtree
  AnimationManagerFinder finder;
  node->accept(finder);
  if (finder._am.valid()) {
    hasOpenSceneGraphAnimation_ = true;

    osgAnimation::AnimationList animlst = finder._am->getAnimationList();
    osg::ref_ptr<osgAnimation::Animation> animation = animlst[0];
    std::cout << "Animation Duration: " << animation->getDuration() << ", Starttime: " << animation->getStartTime() << std::endl;

    animationManager_.registerAnimation(animation);
#ifdef WIN32
    animation->setPlaymode(osgAnimation::Animation::ONCE);
#else
    animation->setPlayMode(osgAnimation::Animation::ONCE);
#endif
    node->setUpdateCallback(&animationManager_);

    std::cout << "found animation" << std::endl;
    }


  sw->setAllChildrenOn();

  NodeInfoMap_[sw.get()].NodeType = eNT_FromDisk;
  NodeInfoMap_[sw.get()].FileName = fileName;
  OpenSceneGraphHelper::AddOrSetInfo(sw, SOSG_KEY_IS_MODEL_SWITCH, 
                                     "TRUE");

  rootTree_->dirtyBound();
  //fix transparent nodes 
  // disabled fkellner
  //DisableZWriteForTransparentNodes_();
  return 0;
}


int SceneOpenSceneGraph::
AppendSubTreeFromImageFile(const string& fileName,
                           const double& width_mm,
                           osg::ref_ptr<osg::Node>& imageNode)
{
  if ( !imageNode.valid() ) return -1;
  osg::ref_ptr<osg::MatrixTransform> mt = new osg::MatrixTransform();   
  SetNodeVisible(mt.get(), true);
  SetNodeOccluder(mt.get(), false);
  mt->addChild(imageNode);

  osg::ref_ptr<osg::Switch> sw = new osg::Switch;
  SetNodeVisible(sw.get(), false);
  if (fileName.empty()) {
    sw->setName(SOSG_SWITCH_PREFIX+(string)"Image");
    mt->setName((string)"Image");
  } else {
    sw->setName(SOSG_SWITCH_PREFIX+FileHandling::Basename(fileName));
    mt->setName(FileHandling::Basename(fileName));
  }
  sw->addChild(mt);

  NodeInfoMap_[mt.get()].FileName = fileName;
  NodeInfoMap_[mt.get()].Name = FileHandling::Basename(fileName);
  NodeInfoMap_[mt.get()].NodeType = eNT_FromImageFile;
  NodeInfoMap_[mt.get()].SizeMM = width_mm;
  NodeInfoMap_[mt.get()].IsEditable = true;
  OpenSceneGraphHelper::AddOrSetInfo(mt, SOSG_KEY_NODE_TYPE, 
                                     NodeType2String(eNT_FromImageFile));
  OpenSceneGraphHelper::AddOrSetInfo(mt, SOSG_KEY_FILE_NAME, 
                                     fileName);
  OpenSceneGraphHelper::AddOrSetInfo(mt, SOSG_KEY_NAME, 
                                     FileHandling::Basename(fileName) + 
                                     FileHandling::Suffix(fileName));
  OpenSceneGraphHelper::AddOrSetInfo(mt, SOSG_KEY_IS_EDITABLE, "TRUE");
  ostringstream oss;
  oss << setprecision(7) << width_mm ;
  OpenSceneGraphHelper::AddOrSetInfo(mt, SOSG_KEY_SIZE_MM, oss.str());

  // enable rendering of all osg:switch children
  sw->setAllChildrenOn(); 
  // assigning RenderBin 10 for occluding possibilities
  osg::StateSet *stateset = (mt.get())->getOrCreateStateSet();
  stateset->setRenderBinDetails( 10, "RenderBin");
  rootTree_->addChild(sw.get());
  rootTree_->dirtyBound();

  imageNode = sw.get(); // HACK, not very well tested, friso 2009-04  
  NodeInfoMap_[imageNode.get()].FileName = fileName;
  NodeInfoMap_[imageNode.get()].Name = FileHandling::Basename(fileName);
  NodeInfoMap_[imageNode.get()].NodeType = eNT_FromImageFile;
  NodeInfoMap_[imageNode.get()].SizeMM = width_mm;
  NodeInfoMap_[imageNode.get()].IsEditable = true;
  //SetNodeOccluder(imageNode.get(), false);
  OpenSceneGraphHelper::AddOrSetInfo(sw, SOSG_KEY_IS_MODEL_SWITCH, 
                                     "TRUE");
  return 0;
}


void SceneOpenSceneGraph::
Clear()
{
  NodeInfoMap_.clear();
  CreateStandardNodes_();
}


void SceneOpenSceneGraph::
RemoveSubTreeAndParents(osg::Node* Node)
{
  if (!Node)
    return;
  //find top parent below global root
  osg::Node::ParentList parlist = Node->getParents();
  osg::Node* actnode = Node;
  if (parlist.size() != 0)
    {
      osg::Group* pargoup = parlist[0];
      while (pargoup != rootTree_.get())
        {
          actnode = pargoup;
          parlist = actnode->getParents();BIASASSERT(parlist.size()!=0);//this happens if node isn't in rootree
          pargoup = parlist[0];
        }
    }
  //remove sub tree
  RemoveSubTree(actnode);
  rootTree_->dirtyBound();
}


void SceneOpenSceneGraph::
RemoveSubTree(osg::ref_ptr<osg::Node>& childNode)
{
  //delete entries of subtreenodes from nodeinfomap:
  NodeInfoEraseOp erasor;
  NodeInfoOpenSGVisitor erasevisitor(&NodeInfoMap_, &erasor);
  childNode->accept(erasevisitor);
  //delete osg nodes
  if (!rootTree_->removeChild(childNode.get())){
    BIASERR("not a valid child node "<<childNode.get());
  }
  rootTree_->dirtyBound();
}


bool SceneOpenSceneGraph::
SaveSubTree(osg::Node *node, const std::string &fileName)
{
  if (!node)
    {
      return false;
    }
  osg::Node *myNode = node;

  string path, base, suffix;
  FileHandling::SplitName(fileName, path, base, suffix);

  std::transform(suffix.begin(), suffix.end(), suffix.begin(), (int
  (*)(int)) std::tolower);
  BCDOUT(D_SCENEOSG_MatrixTransform, "saving suffix: "<<suffix<< endl);
  osg::ref_ptr<osg::MatrixTransform> mt;
  if (suffix == ".wrl")
    {
      BCDOUT(D_SCENEOSG_MatrixTransform, "found wrl file, adding matrix "
          <<"transform for compensation\n");
      // osg wrl export automatically adds a transform node (rotation around
      // x-axis). This needs to be compensated
      mt = new osg::MatrixTransform(osg::Matrix(1, 0, 0, 0, 0, 0, 1, 0, 0, -1,
          0, 0, 0, 0, 0, 1));
      mt->addChild(node);
      mt->setName(node->getName());
      myNode = mt.get();
    }

  osgDB::writeNodeFile(*myNode, fileName);

  return true;
}


/*
void SceneOpenSceneGraph::
MergeTransforms_(osg::Node *node)
 {
 if(!node) {
 BCDOUT(D_SCENEOSG_IdentifyMatrixTransform, "zero node\n");
 return;
 }

 // check if parent is also a matrix transform
 if (node->getNumParents()!=0){
 osg::Node *parent = node->getParent(0);
 osg::Transform* t = parent->asTransform();
 osg::MatrixTransform* tm = 0;
 if(t) {
 tm = t->asMatrixTransform();
 }
 if(tm && t) {
 // parent is matrix transfrom, Merge must be called from topmost node
 return MergeTransforms_(parent);
 }
 }

 // check for child amd grandchild



 // check if node is matrix transform
 osg::Transform* t = node->asTransform();
 if(!t) {
 BCDOUT(D_SCENEOSG_IdentifyMatrixTransform, "not a transform node\n");
 return;
 }
 osg::MatrixTransform* tm = t->asMatrixTransform();
 if(!tm) {
 BCDOUT(D_SCENEOSG_IdentifyMatrixTransform, "not a matrix transform node\n");
 return;
 }
 osg::Matrix m = tm->getMatrix();

 // check if child is also a matrix transform
 t = child->asTransform();
 if(!t) {
 BCDOUT(D_SCENEOSG_IdentifyMatrixTransform, "not a transform node\n");
 return;
 }
 tm = t->asMatrixTransform();
 if(!tm) {
 BCDOUT(D_SCENEOSG_IdentifyMatrixTransform, "not a matrix transform node\n");
 return;
 }
 osg::Matrix cm = tm->getMatrix();

 // check

}
*/


void SceneOpenSceneGraph::
RemoveSubTree(osg::Node* childNode)
{
  if (!childNode)
    return;
  //delete entries of subtreenodes from nodeinfomap:
  NodeInfoEraseOp erasor;
  NodeInfoOpenSGVisitor erasevisitor(&NodeInfoMap_, &erasor);
  childNode->accept(erasevisitor);
  //delete osg nodes
  if (!rootTree_->removeChild(childNode))
    {
        BIASERR("not a valid child node "<<childNode);
    }
}


bool SceneOpenSceneGraph::
Save(std::string filename)
{
  //iterate through all nodeinfoentries
  std::map<osg::Node*, NodeInfo>::iterator it;
  for (it = NodeInfoMap_.begin(); it != NodeInfoMap_.end(); it++)
    {
      osg::Node* node = (*it).first;
      if (!node)
        {
            BIASWARN("Null pointer in nodeinfo list");
          continue;
        }
      //get node ptr and generate id string from it
      (*it).second.Id = NodePtr2IDString_(node);
      //save name of node
      (*it).second.Name = node->getName();
      node->setName((*it).second.Id);
    }
  std::string dir;
  std::string base;
  std::string suffix;
  //export nodeinfomap as xmlfile
  FileHandling::SplitName(filename, dir, base, suffix);

  if (NodeInfoMap_.XMLWrite(dir + base + ".xml") != 0)
    return false;

  //export complete scene graph
  string ivename = dir + base + ".ive";
  //why do we write only ive, there os a seg fault in attempting to write 3ds
  //string ivename = dir + base + suffix;
  if (!osgDB::writeNodeFile(*rootTree_, ivename))
    {
      return false;
    }
  //restore node names
  for (it = NodeInfoMap_.begin(); it != NodeInfoMap_.end(); it++)
    {
      osg::Node* node = (*it).first;
      if (!node)
        {
            BIASWARN("Null pointer in nodeinfo list");
          continue;
        }
      node->setName((*it).second.Name);
    }
  return true;
}


bool SceneOpenSceneGraph::
Load(std::string filename)
{
  std::string dir;
  std::string base;
  std::string suffix;
  //export nodeinfomap as xmlfile
  FileHandling::SplitName(filename, dir, base, suffix);

  osg::ref_ptr<osg::Node> tempNode;
  string modelfilename = dir + base + ".ive";

  tempNode = osgDB::readNodeFile(modelfilename);
  if (!tempNode)
    return false;
  osg::ref_ptr<osg::Group> tempGroup;
  tempGroup = tempNode->asGroup();
  if (!tempGroup)
    {
        BIASWARN("not a valid scene tree file");
      return false;
    }

  //load nodeinfos
  NodeInfoMap tempMap; //contains invalid pointers as key
  string xmlpath = dir + base + ".xml";
  if (tempMap.XMLRead(xmlpath) != 0)
    {
        BIASWARN(xmlpath<<" not found");
      return false;
    }
  NodeInfoMap_.clear(); //clear map and rebuild it from tempmap
  //visit all treenodes check for nodeinfo in tempmap and correct
  //node name and add new node info with corrected pointer to NodeInfoMap_
  NodeInfoRestoreNameOp op;
  op.targetMap = &NodeInfoMap_;
  NodeInfoOpenSGVisitor namerestorevisitor(&tempMap, &op);
  tempGroup->accept(namerestorevisitor); //here we go...

  //copy new root ptr to rootnode
  rootTree_ = tempGroup;
  sceneView_->setSceneData(rootTree_.get());
  return true;
}


std::string SceneOpenSceneGraph::
NodePtr2IDString_(osg::Node* node)
{
  stringstream ss;
  ss.fill('0');
  ss << node; //stream the pointer to string
  return (ss.str());
}


void SceneOpenSceneGraph::
SetFixedPointLight(bool on, Vector3<double> posPointLight)
{
  if(!on){
    light_->setAmbient( osg::Vec4( .0f, .0f, .0f, .0f ));
    light_->setDiffuse( osg::Vec4( .0f, .0f, .0f, .0f ));
    light_->setSpecular( osg::Vec4( .0f, .0f, .0f, .0f ));
  }
  else{
    light_->setAmbient( osg::Vec4( .3f, .3f, .3f, 1.0f ));
    //  light_->setAmbient( osg::Vec4(1.0f,1.0f,1.0f,1.0f ));
    light_->setDiffuse( osg::Vec4( 1.0f, 1.0f, 1.0f, 1.0f ));
    light_->setSpecular( osg::Vec4( 1.0f, 1.0f, 1.0f, 1.0f ));


    headlight_ = false;
    osg::Matrix m;
    m.makeTranslate(osg::Vec3(posPointLight[0], posPointLight[1],
                              posPointLight[2]));
    lightTransform_->setMatrix(m);
  }
}


void SceneOpenSceneGraph::
SetFixedDirectionalLight(bool on, Vector3<double> dirDirectionalLight)
{
  //    BIASERR("unfinished");
}


void SceneOpenSceneGraph::
HeadlightSwitch(bool on)
{
  headlight_ = on;
}


void SceneOpenSceneGraph::
SetAnimate(const bool animate)
{
  animate_ = animate;
  osg::Timer_t t1 = osg::Timer::instance()->tick();
  double time = osg::Timer::instance()->delta_s(startTick_, t1);
  if (animate_)
    {
      timeOffset_ += time - lastPauseTime_;
    }
  else
    {
      lastPauseTime_ = time;
    }
}



class transparentColourValueVisitor : public osg::ValueVisitor
{
public:
  transparentColourValueVisitor() :
    osg::ValueVisitor(), transparency_(0.5)
  {
  }

  transparentColourValueVisitor(const double transparency) :
    osg::ValueVisitor(), transparency_(transparency)
  {
  }

  virtual void
  apply(osg::Vec4 &v)
  {
    v[3] = 1.0 - transparency_;
  }

  virtual void apply(osg::Vec4ub &v)
  { v[3] = (unsigned char)(255.0*(1.0-transparency_)); }

private:
  double transparency_;
};

class transparentColourArrayVisitor : public osg::ArrayVisitor
{
public:
  transparentColourArrayVisitor() :
    osg::ArrayVisitor(), transparency_(0.5)
  {
  }

  transparentColourArrayVisitor(const double transparency) :
    osg::ArrayVisitor(), transparency_(transparency)
  {
  }

  virtual void
  apply(osg::Vec4Array &va)
  { //cout << "a" << flush;
    transparentColourValueVisitor tcvv(transparency_);
    const unsigned num = va.getNumElements();
    for (unsigned i = 0; i < num; i++)
      {
        va.accept(i, tcvv);
      }
  }

  virtual void apply(osg::Vec4ubArray &va)
  {
    transparentColourValueVisitor tcvv(transparency_);
    const unsigned num = va.getNumElements();
    for (unsigned i=0; i<num; i++){
      va.accept(i,tcvv);
    }
  }

private:
  double transparency_;
};

class makeTransparentNodeVisitor : public osg::NodeVisitor
{
public:

  // Default constructor - initialize searchForName to "" and
  // set the traversal mode to TRAVERSE_ALL_CHILDREN
  makeTransparentNodeVisitor() :
    osg::NodeVisitor(TRAVERSE_ALL_CHILDREN), transparency_(0.5)
  {
  }

  // Constructor that accepts string argument
  // Initializes searchForName to user string
  // set the traversal mode to TRAVERSE_ALL_CHILDREN
  makeTransparentNodeVisitor(const double transparency) :
    osg::NodeVisitor(TRAVERSE_ALL_CHILDREN), transparency_(transparency)
  {
    BIASASSERT(transparency>=0.0 && transparency<=1.0);
  }

  virtual void
  apply(osg::Geode &node)
  {
    unsigned num_drawables = node.getNumDrawables();
    for (unsigned int i = 0; i < num_drawables; i++)
      {
        osg::Geometry *geom = node.getDrawable(i)->asGeometry();
        if (geom)
          {
            //cout << "g"<<flush;
            osg::Array *col = geom->getColorArray();
            //cout << col->getNumElements() << flush;
            if (!col)
              return;
            transparentColourArrayVisitor tcav(transparency_);
            col->accept(tcav);
          }
        else
          {
            //cout << "x"<<flush;
          }
        //cout << endl;
      }
  }

  virtual void
  apply(osg::ClearNode &node)
  {
    //cout << "c"<<flush;
    node.setClearMask(0);
  }

  // Set the searchForName to user-defined string
  inline void
  setTransparency(const double transparency)
  {
    BIASASSERT(transparency>=0.0 && transparency<=1.0);
    transparency_ = transparency;
  }

private:
  double transparency_;

};

void SceneOpenSceneGraph::
MakeTransparent(const double transparency)
{
  BIASASSERT(transparency>=0.0 && transparency<=1.0);

  osg::StateSet *stateset = rootTree_->getOrCreateStateSet();

  stateset->setMode(GL_BLEND, osg::StateAttribute::ON
      | osg::StateAttribute::OVERRIDE);

  osg::BlendEquation* blendEquation = new osg::BlendEquation(
      osg::BlendEquation::FUNC_ADD);
  osg::BlendFunc* pBlendFunc = new osg::BlendFunc(osg::BlendFunc::SRC_ALPHA,
                          osg::BlendFunc::ONE_MINUS_SRC_ALPHA);
  stateset->setAttributeAndModes(pBlendFunc, osg::StateAttribute::OVERRIDE |
                                      osg::StateAttribute::ON);
  
  stateset->setAttributeAndModes(blendEquation, osg::StateAttribute::OVERRIDE
      | osg::StateAttribute::ON);

  stateset->setMode(GL_CULL_FACE, osg::StateAttribute::ON
      | osg::StateAttribute::OVERRIDE);

  // TODO VN culls BACK, CAU culls FRONT
  osg::CullFace *cullFace = new osg::CullFace(osg::CullFace::BACK);
  //osg::CullFace *cullFace = new osg::CullFace(osg::CullFace::FRONT);
  //osg::CullFace *cullFace = new osg::CullFace(osg::CullFace::FRONT_AND_BACK );
  stateset->setAttribute(cullFace);
  
  //   stateset->setMode(GL_DEPTH_TEST, osg::StateAttribute::OFF |
  //                     osg::StateAttribute::OVERRIDE );

  // the object in the opaque bin are rendered before the object in the
  // transparent bin, to allow propper blending
  stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);

  makeTransparentNodeVisitor tnv(transparency);
  rootTree_->accept(tnv);
  sceneView_->init();
}


void SceneOpenSceneGraph::
SetAnimationTime(const double current_time, bool CallDraw)
{
  if (animate_)
    {
        BEXCEPTION("you can't animate automatically and set time manually");
    }
  frameStamp_->setFrameNumber(frameStamp_->getFrameNumber() + 1);  
  frameStamp_->setReferenceTime(current_time);
  frameStamp_->setSimulationTime(current_time);
  if(CallDraw)
  {
  Draw(); //WTF?
  }
}

void SceneOpenSceneGraph::
Draw()
{
  if (animate_) {
    osg::Timer_t t1 = osg::Timer::instance()->tick();
    double time = osg::Timer::instance()->delta_s(startTick_, t1);
    frameStamp_->setFrameNumber(frameStamp_->getFrameNumber()+1);
    frameStamp_->setReferenceTime(time);
    frameStamp_->setSimulationTime(time - timeOffset_);
  }
 
  // OpenSceneGraph is managing this
  //  glPushAttrib( GL_ALL_ATTRIB_BITS );
  glPushAttrib( GL_VIEWPORT_BIT );
  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glMatrixMode(GL_TEXTURE);
  glPushMatrix();
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();

  GLint viewParams[4];
  glGetIntegerv( GL_VIEWPORT, viewParams );
  sceneView_->getCamera()->setViewport(viewParams[0], viewParams[1],
                                       viewParams[2], viewParams[3]);

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

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

  // cout <<"Projection (in SceneOpenSceneGraph):"<<endl;
  // for (unsigned int j=0;j<4;j++){
  //   for (unsigned int i=0;i<4;i++)
  //     cout <<glMat[j*4+i]<<"    ";
  //   cout <<endl;
  // }
  glGetFloatv( GL_MODELVIEW_MATRIX, glMat );

  //  cout <<"ModelView (in SceneOpenSceneGraph):"<<endl;
  // for (unsigned int j=0;j<4;j++){
  //   for (unsigned int i=0;i<4;i++)
  //     cout <<glMat[j*4+i]<<"    ";
  //   cout <<endl;
  // }
  osgMat.set( glMat );
  if (headlight_){
    //cout<<"Headlight!"<<endl;
    osg::Vec3d eye, center, up;
    float lookDistance=1.0;
    osgMat.getLookAt (eye, center, up, lookDistance);
    osg::Matrix m;
    m.makeTranslate(eye);  
    lightTransform_->setMatrix(m);
  }
  sceneView_->getCamera()->getViewMatrix().set( osgMat );
  
  GLbitfield mask = sceneView_->getCamera()->getClearMask();
  sceneView_->getCamera()->setClearMask(0);
  
  //(sceneView_->getCamera())->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT);
  // do the update traversal the scene graph - such as updating animations
  sceneView_->updateTraversal();
  sceneView_->renderingTraversals();
  if (sceneView_.valid()) sceneView_->frame();


  GLint  drawenum;
  glGetIntegerv(GL_DRAW_BUFFER,&drawenum);

  //   sceneView_->setDrawBufferValue(drawenum);
  //workaround for osgview when using framebuffer objects in glprojection**

  // TODO the following ghas been disabled by CAU, was enabled at VN
  //(sceneView_->getState())->setCheckForGLErrors(osg::State::ONCE_PER_ATTRIBUTE);

  sceneView_->getCamera()->setClearMask(mask);

  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
  glMatrixMode(GL_TEXTURE);
  glPopMatrix();
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glPopAttrib();

}


BIAS::Vector3<double> SceneOpenSceneGraph::
GetBoundingBoxCenter()
{
  const osg::BoundingSphere& bs = rootTree_->getBound();

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


void SceneOpenSceneGraph::
GetBoundingBox(BIAS::Vector3<double> &min, BIAS::Vector3<
    double> &max)
{
  const osg::BoundingSphere& bs = rootTree_->getBound();

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

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

  Vector3<double> diag(radius, radius, radius);
  min = center - diag;
  max = center + diag;
}


bool SceneOpenSceneGraph::
RightMouseDoubleClicked(int x, int y)
{

  BIAS::GLProjectionParametersInterface* camera = GetGLProjectionParametersInterface();
  double depth = camera->GetDepth(x, y);
  if (depth <= 0.0)
    return false;
  HomgPoint2D thepoint(x, y);
  HomgPoint3D intersection = camera->GetMyselfAsProjectionParametersBase()->
    UnProjectToPoint(thepoint, depth);
  cout << "viewing ray intersects scene at " << intersection << endl;
  return true;
}


osg::ref_ptr<osg::Node> SceneOpenSceneGraph::
GetSceneRoot()
{
  return (osg::dynamic_pointer_cast<osg::Node>(rootTree_));
}


TreeDescr SceneOpenSceneGraph::
GetTreeDescr()
{
  TreeDescr res;
  res.RootNode = GetSceneRoot();
  res.pNodeInfoMap = &NodeInfoMap_;
  return res;
}


void SceneOpenSceneGraph::
SetNodeVisible(osg::Node* node, const bool visible)
{
  //affects only the display in graph visualization guis
  //e.g. the tree control. this has no effect on
  //the visibility of the node during rendering!!
  NodeInfoMap_[node].IsVisible = visible;
  const string vis = (visible)?("TRUE"):("FALSE");
  OpenSceneGraphHelper::AddOrSetInfo(node, SOSG_KEY_IS_VISIBLE, vis);
}


void SceneOpenSceneGraph::
SetNodeMarkerID(osg::Node* node, const unsigned long long &id)
{
  NodeInfoMap_[node].MarkerID = id;
  ostringstream oss;
  oss << id;
  OpenSceneGraphHelper::AddOrSetInfo(node, SOSG_KEY_MARKER_ID, oss.str());
}


void SceneOpenSceneGraph::
SetNodeOccluder(osg::Node* node, const bool state)
{
  NodeInfoMap_[node].IsOccluder = state;
  const string occ = (state)?("TRUE"):("FALSE");
  OpenSceneGraphHelper::AddOrSetInfo(node, SOSG_KEY_IS_OCCLUDER, occ);

  osg::StateSet *stateset = node->getOrCreateStateSet();
  BIASASSERT(stateset);
  osg::ColorMask *colmask = new osg::ColorMask(!state, !state, !state, !state);
  stateset->setAttribute(colmask);
  osg::Stencil   *stencil = new osg::Stencil();
 
  if(state) 
  {
    stateset->setRenderBinDetails( 1, "RenderBin"/* ,osg::StateSet::OVERRIDE_RENDERBIN_DETAILS*/);
    //stencil->setFunction( osg::Stencil::ALWAYS, 2, ~(unsigned int)0);
    //if buffer >1 do nothing because 2 is overlay geometry
    stencil->setFunction( osg::Stencil::GREATER, 1, ~(unsigned int)0); //is stencil 2 ?
    //if stencilbuffer <=1 (stencil test fails) -> keep stencil buffer 1 or 2
    //if sp >1 (passes) and ztest fails -> keep stencil at 1
    //if sp >1 and ztest passes 
    stencil->setOperation(osg::Stencil::KEEP,osg::Stencil::KEEP,
                        osg::Stencil::REPLACE);  

  }
  else 
  {
    stateset->setRenderBinDetails( 10, "RenderBin"/*, osg::StateSet::OVERRIDE_RENDERBIN_DETAILS*/);    
    //stencil->setFunction( osg::Stencil::ALWAYS, 0, ~(unsigned int)0);
    //stencil test passes if reference value is not equal to stencil buffer    
    stencil->setFunction( osg::Stencil::NOTEQUAL, 2, ~(unsigned int)0);  
    //operation stencil fail, stencilpass und zfail, zpass
    //if stencilbuffer == 2 (stenciltest fails) -> keep stencilbuffer 2 (btw: 2 means overlay geometry)
    //if stencilbuffer != 2 (passes) and ztest fails -> also keep stencilbuffer (most likely 1)
    //if stencilbuffer != 2 and ztest passes. set stencil to 0 
    stencil->setOperation(osg::Stencil::KEEP,osg::Stencil::KEEP,
                          osg::Stencil::ZERO); //set to zero if passes this changes occluder's 1 to 0       
  }

  #if (OPENSCENEGRAPH_MAJOR_VERSION>=2) && (OPENSCENEGRAPH_MINOR_VERSION>=8)
     stateset->setNestRenderBins(false);
  #endif  
  stateset->setAttributeAndModes(stencil); //default is on!
}


bool SceneOpenSceneGraph::
IsEditableNode(osg::Node* node)
{
  if (!node)
    return false;
  osg::Transform * t;
  t = node->asTransform();
  if (!t)
    return false;
  osg::MatrixTransform * tm;
  tm = t->asMatrixTransform();
  if (!tm)
    return false;
  //check editable flag from nodeinfo map

  string val;
  if (OpenSceneGraphHelper::HasInfo(node, SOSG_KEY_IS_EDITABLE, val)){
    BIASASSERT(NodeInfoMap_.NodeHasNodeInfo(node));
    BIASASSERT( (NodeInfoMap_[node].IsEditable && (val=="TRUE") ) ||
                (!NodeInfoMap_[node].IsEditable && (val!="TRUE") ) ); 
    return (val=="TRUE");
  }
  //  if (NodeInfoMap_.NodeHasNodeInfo(node)){
  //  return ((NodeInfoMap_[node]).IsEditable);
  //}
  return true;
}


void SceneOpenSceneGraph::
MakeRootShadowNode(osg::ref_ptr<osg::LightSource> lightSource)
{
  //TODO test if shadow node is already inserted:

  //  const int ReceivesShadowTraversalMask = 0x1;
  //  const int CastsShadowTraversalMask = 0x2;

  osg::ref_ptr<osg::Group> temproot = rootTree_;

  //create new shadow technique
  osg::ref_ptr<osgShadow::ShadowMap> st = new osgShadow::ShadowMap;
  //create shadownode and add technique
  //osg::ref_ptr<osgShadow::ShadowedScene> shadowedScene =
  rootTree_ = new osgShadow::ShadowedScene(st.get());
  rootTree_->setName("_sceneRootShadowed");
  //add old root's children to shadow node
  for (unsigned int n = 0; n < (temproot->getNumChildren()); n++)
    {
      rootTree_->addChild(temproot->getChild(n));
    }

  osg::ref_ptr<osgShadow::ShadowedScene> shadowedScene =
      osg::dynamic_pointer_cast<osgShadow::ShadowedScene>(rootTree_);
  dynamic_cast<osgShadow::ShadowMap*> (shadowedScene->getShadowTechnique()) ->setLight(
      lightSource.get());
  //shadowedScene->addChild(rootTree_.get());
  // shadowedScene->setReceivesShadowTraversalMask(ReceivesShadowTraversalMask);
  // shadowedScene->setCastsShadowTraversalMask(CastsShadowTraversalMask);
  //   //set shadownode as new root
  //   rootTree_ = shadowedScene->asGroup();
}


/** @brief  helper function for mirror effects, called for all subscenes */
osg::Node* SceneOpenSceneGraph::
createMirroredScene(osg::Node* model, const BIAS::Vector3<
    double>& ul, const BIAS::Vector3<double>& ur,
    const BIAS::Vector3<double>& ll, const BIAS::Vector3<double>& lr,
    const string &mirrortexture, bool cutUpperHalf)
{

  osg::Geometry* geom = new osg::Geometry;

  osg::Vec3Array* coords = new osg::Vec3Array(4);
  (*coords)[0].set(ll[0], ll[1], ll[2]); //(xMin,yMax,z);
  (*coords)[1].set(ul[0], ul[1], ul[2]);
  (*coords)[2].set(ur[0], ur[1], ur[2]);
  (*coords)[3].set(lr[0], lr[1], lr[2]);

  //cout<<" "<<ll[0]<<" "<<ll[1]<<" "<<ll[2]<<endl;
  //cout<<" "<<ul[0]<<" "<<ul[1]<<" "<<ul[2]<<endl;
  //cout<<" "<<ur[0]<<" "<<ur[1]<<" "<<ur[2]<<endl;
  //cout<<" "<<lr[0]<<" "<<lr[1]<<" "<<lr[2]<<endl;

  geom->setVertexArray(coords);

  osg::Vec3Array* norms = new osg::Vec3Array(1);
  Vector3<double> norm((ul - ur).CrossProduct(ul - ll));
  norm.Normalize();
  //  (*norms)[0].set(0.0f,0.0f,1.0f);

  Vector3<double> center2(ul + ur + ll + lr);
  center2 *= 0.25;
  center2.Normalize();

  //  (*norms)[0].set(norm[0], norm[1], norm[2]);
  (*norms)[0].set(-center2[0], -center2[1], -center2[2]);
  geom->setNormalArray(norms);
  geom->setNormalBinding(osg::Geometry::BIND_OVERALL);

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

  osg::Vec4Array* colours = new osg::Vec4Array(1);
  //  (*colours)[0].set(0.5f,.5f,.5,0.6f);
  (*colours)[0].set(1.0f, 1.0f, 1.0f, 1.0f);
  geom->setColorArray(colours);
  geom->setColorBinding(osg::Geometry::BIND_OVERALL);

  geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS, 0, 4));

  // create a textured, transparent node at the appropriate place.
  osg::Drawable* mirror = geom;

  osg::MatrixTransform* rootNode = new osg::MatrixTransform;
  //rootNode->setMatrix(osg::Matrix::rotate(osg::inDegrees(45.0f),1.0f,0.0f,0.0f));

  // make sure that the global color mask exists.
  osg::ColorMask* rootColorMask = new osg::ColorMask;
  rootColorMask->setMask(true, true, true, true);

  // set up depth to be inherited by the rest of the scene unless
  // overrideen. this is overridden in bin 3.
  osg::Depth* rootDepth = new osg::Depth;
  rootDepth->setFunction(osg::Depth::LESS);
  rootDepth->setRange(0.0, 1.0);

  osg::StateSet* rootStateSet = new osg::StateSet();
  rootStateSet->setAttribute(rootColorMask);
  rootStateSet->setAttribute(rootDepth);

  rootNode->setStateSet(rootStateSet);

  // bin1  - set up the stencil values and depth for mirror.
    {

      // set up the stencil ops so that the stencil buffer get set at
      // the mirror plane
      osg::Stencil* stencil = new osg::Stencil;
      stencil->setFunction(osg::Stencil::ALWAYS, 1, ~0u);
      stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP,
          osg::Stencil::REPLACE);

      // switch off the writing to the color bit planes.
      osg::ColorMask* colorMask = new osg::ColorMask;
      colorMask->setMask(false, false, false, false);

      osg::StateSet* statesetBin1 = new osg::StateSet();
      statesetBin1->setRenderBinDetails(1, "RenderBin");
      statesetBin1->setMode(GL_CULL_FACE,osg::StateAttribute::OFF);
      statesetBin1->setAttributeAndModes(stencil, osg::StateAttribute::ON);
      statesetBin1->setAttribute(colorMask);

      // set up the mirror geode.
      osg::Geode* geode = new osg::Geode;
      geode->addDrawable(mirror);
      geode->setStateSet(statesetBin1);
      rootNode->addChild(geode);

    }

  // bin one - draw scene without mirror or reflection, unset
  // stencil values where scene is infront of mirror and hence
  // occludes the mirror.
    {
      osg::Stencil* stencil = new osg::Stencil;
      stencil->setFunction(osg::Stencil::ALWAYS, 0, ~0u);
      stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP,
          osg::Stencil::REPLACE);

      osg::StateSet* statesetBin2 = new osg::StateSet();
      statesetBin2->setRenderBinDetails(2, "RenderBin");
      statesetBin2->setAttributeAndModes(stencil, osg::StateAttribute::ON);

      osg::Group* groupBin2 = new osg::Group();
      groupBin2->setStateSet(statesetBin2);
      groupBin2->addChild(model);

      // comment out
      if (!cutUpperHalf)
        rootNode->addChild(groupBin2);
    }

  // bin3  - set up the depth to the furthest depth value
    {

      // set up the stencil ops so that only operator on this mirrors stencil value.
      osg::Stencil* stencil = new osg::Stencil;
      stencil->setFunction(osg::Stencil::EQUAL, 1, ~0u);
      stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP,
          osg::Stencil::KEEP);

      // switch off the writing to the color bit planes.
      osg::ColorMask* colorMask = new osg::ColorMask;
      colorMask->setMask(false, false, false, false);

      // set up depth so all writing to depth goes to maximum depth.
      osg::Depth* depth = new osg::Depth;
      depth->setFunction(osg::Depth::ALWAYS);
      depth->setRange(1.0, 1.0);

      osg::StateSet* statesetBin3 = new osg::StateSet();
      statesetBin3->setRenderBinDetails(3, "RenderBin");
      statesetBin3->setMode(GL_CULL_FACE,osg::StateAttribute::OFF);
      statesetBin3->setAttributeAndModes(stencil, osg::StateAttribute::ON);
      statesetBin3->setAttribute(colorMask);
      statesetBin3->setAttribute(depth);

      // set up the mirror geode.
      osg::Geode* geode = new osg::Geode;
      geode->addDrawable(mirror);
      geode->setStateSet(statesetBin3);

      rootNode->addChild(geode);

    }

  // bin4  - draw the reflection.
    {

      // now create the 'reflection' of the loaded model by applying
      // create a Transform which flips the loaded model about the z axis
      // relative to the mirror node, the loadedModel is added to the
      // Transform so now appears twice in the scene, but is shared so there
      // is negligable memory overhead.  Also use an osg::StateSet
      // attached to the Transform to override the face culling on the subgraph
      // to prevert an 'inside' out view of the reflected model.
      // set up the stencil ops so that only operator on this mirrors stencil value.


      // this clip plane removes any of the scene which when mirror would
      // poke through the mirror.  However, this clip plane should really
      // flip sides once the eye point goes to the back of the mirror...
      osg::ClipPlane* clipplane = new osg::ClipPlane;

      Vector3<double> normal((ul - ur).CrossProduct(ul - ll));
      normal.Normalize();
      osg::Vec3 onormal(-normal[0], -normal[1], -normal[2]);
      Vector3<double> center(ul + ur + ll + lr);
      center *= 0.25;
      osg::Plane theclipplane(onormal, osg::Vec3(center[0], center[1],
          center[2]));
      cout << "clipplane is " << theclipplane[0] << " " << theclipplane[1]
          << " " << theclipplane[2] << " " << theclipplane[3] << " " << endl;
      clipplane->setClipPlane(theclipplane);
      clipplane->setClipPlaneNum(0);

      osg::ClipNode* clipNode = new osg::ClipNode;
      clipNode->addClipPlane(clipplane);

      osg::StateSet* dstate = clipNode->getOrCreateStateSet();
      dstate->setRenderBinDetails(4, "RenderBin");
      dstate->setMode(GL_CULL_FACE,osg::StateAttribute::OVERRIDE
          | osg::StateAttribute::OFF);

      osg::Stencil* stencil = new osg::Stencil;
      stencil->setFunction(osg::Stencil::EQUAL, 1, ~0u);
      stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP,
          osg::Stencil::KEEP);
      dstate->setAttributeAndModes(stencil, osg::StateAttribute::ON);

      osg::MatrixTransform* reverseMatrix = new osg::MatrixTransform;
      reverseMatrix->setStateSet(dstate);

      osg::Matrix rot, rott;
      rot.makeRotate(osg::Vec3(0, 0, 1), onormal);
      rott.invert(rot);

      reverseMatrix->preMult(osg::Matrix::translate(-center[0], -center[1],
          -center[2]) * rott * osg::Matrix::scale(1.0f, 1.0f, -1.0f) * rot
          * osg::Matrix::translate(center[0], center[1], center[2]));

      reverseMatrix->addChild(model);
      clipNode->addChild(reverseMatrix);
      rootNode->addChild(clipNode);
    }

  // bin5  - draw the textured mirror and blend it with the reflection.
    {

      // set up depth so all writing to depth goes to maximum depth.
      osg::Depth* depth = new osg::Depth;
      depth->setFunction(osg::Depth::ALWAYS);

      osg::Stencil* stencil = new osg::Stencil;
      stencil->setFunction(osg::Stencil::EQUAL, 1, ~0u);
      //stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::ZERO);
      stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP,
          osg::Stencil::ZERO);

      // set up additive blending.
      osg::BlendFunc* trans = new osg::BlendFunc;
      // Blending function, the higher the alpha in texture image, the more texture will be seen
      trans->setFunction(osg::BlendFunc::SRC_ALPHA,
          osg::BlendFunc::ONE_MINUS_SRC_ALPHA);

      osg::AlphaFunc* alpha = new osg::AlphaFunc;
      alpha->setFunction(osg::AlphaFunc::ALWAYS);

      osg::StateSet* statesetBin5 = new osg::StateSet;

      statesetBin5->setMode(GL_CULL_FACE,osg::StateAttribute::OFF
          | osg::StateAttribute::PROTECTED);

      // set up the texture.
      osg::Image* image = osgDB::readImageFile(mirrortexture.c_str());
      if (image)
        {
          osg::Texture2D* texture = new osg::Texture2D;
          texture->setImage(image);
          //        texture->setWrap(osg::Texture2D::WRAP_S, osg::Texture2D::REPEAT);
          //        texture->setWrap(osg::Texture2D::WRAP_T, osg::Texture2D::REPEAT);
          statesetBin5->setTextureAttributeAndModes(0, texture,
              osg::StateAttribute::ON | osg::StateAttribute::PROTECTED);
        }
      else
        {
            BIASERR("could not load texture "<<mirrortexture);
        }

      statesetBin5->setRenderBinDetails(5, "RenderBin");
      statesetBin5->setMode(GL_CULL_FACE,osg::StateAttribute::OFF);
      statesetBin5->setAttributeAndModes(stencil, osg::StateAttribute::ON);
      statesetBin5->setAttributeAndModes(trans, osg::StateAttribute::ON);
      statesetBin5->setAttributeAndModes(alpha, osg::StateAttribute::ON);
      statesetBin5->setAttribute(depth);

      // set up the mirror geode.
      osg::Geode* geode = new osg::Geode;
      geode->addDrawable(mirror);
      geode->setStateSet(statesetBin5);

      //    // Add Bump Map to the Mirror - BROKEN! todo
      //    osg::Group *root = new osg::Group();
      //    osgFX::BumpMapping *bump = new osgFX::BumpMapping();
      //    bump->addChild(geode);
      //    /////////////////////////
      //    // assign textures
      //
      //    osg::Texture2D *normal = new osg::Texture2D();
      //    osg::Texture2D *diffuse = new osg::Texture2D();
      //
      //    const char* normal_texture = "/home/fkellner/216-bump.jpg";
      //    const char* diffuse_texture = "/home/fkellner/teich.png";
      //
      //    osg::Image *normal_image  = osgDB::readImageFile( normal_texture );
      //    osg::Image *diffuse_image = osgDB::readImageFile( diffuse_texture );
      //
      //    normal->setImage( normal_image );
      //    normal->setFilter( osg::Texture::MIN_FILTER, osg::Texture::LINEAR_MIPMAP_LINEAR );
      //    normal->setFilter( osg::Texture::MAG_FILTER, osg::Texture::LINEAR );
      //    normal->setWrap( osg::Texture::WRAP_S, osg::Texture::REPEAT );
      //    normal->setWrap( osg::Texture::WRAP_T, osg::Texture::REPEAT );
      //    normal->setMaxAnisotropy(8);
      //
      //    diffuse->setImage( diffuse_image );
      //    diffuse->setFilter( osg::Texture::MIN_FILTER, osg::Texture::LINEAR_MIPMAP_LINEAR );
      //    diffuse->setFilter( osg::Texture::MAG_FILTER, osg::Texture::LINEAR );
      //    diffuse->setWrap( osg::Texture::WRAP_S, osg::Texture::REPEAT );
      //    diffuse->setWrap( osg::Texture::WRAP_T, osg::Texture::REPEAT );
      //    diffuse->setMaxAnisotropy(8);
      //
      //    /////////////////////////////
      //    // create the state set
      //    osg::StateSet *state = new osg::StateSet();
      //    state->setTextureAttributeAndModes( 0, diffuse, osg::StateAttribute::ON );
      //    state->setTextureAttributeAndModes( 1, normal, osg::StateAttribute::ON );
      //    state->setGlobalDefaults();
      //    state->setMode( GL_LIGHTING, osg::StateAttribute::ON );
      //    state->setMode( GL_BLEND, osg::StateAttribute::ON );
      //    state->setRenderingHint( osg::StateSet::TRANSPARENT_BIN );
      //
      //    bump->setStateSet( state );
      //
      //    //////////////////////////////////////////
      //    // create the bump mapping effect
      //
      //    bump->setEnabled( true );
      //    bump->setLightNumber( 0 );
      //    bump->setOverrideNormalMapTexture( normal );
      //    bump->setOverrideDiffuseTexture( diffuse );
      //    bump->prepareChildren();
      //
      //    ///////////////////////////
      //    // add to the scene
      //
      //    osg::MatrixTransform *MT = new osg::MatrixTransform();
      //    MT->addChild( bump );
      //
      //    root->addChild( MT );
      //    rootNode->addChild(root);
      //
      //    //rootNode->addChild(loadedModel);


      rootNode->addChild(geode);

    }
  //  static int n=0;
  //  osgDB::writeNodeFile(*rootNode, "mirror"+LeadingZeroString(n,2)+".osg");
  rootNode->setName(model->getName() + "_mirrored");
  return rootNode;
}


void SceneOpenSceneGraph::
AddMirror(const BIAS::Vector3<double>& ul, const BIAS::Vector3<double>& ur, 
      const BIAS::Vector3<double>& ll, const BIAS::Vector3<double>& lr, 
      const string& mirrortexture, bool cutUpperHalf)
{

  cout << "SceneOpenSceneGraph has " << rootTree_->getNumChildren()
      << " children..." << endl;
  for (unsigned int i = 0; i < rootTree_->getNumChildren(); i++)
    {
      osg::Node *node = rootTree_->getChild(i);
      cout << "creating reflection for subtree " << i << " with name "
          << node->getName() << endl;
      //    if (node->getName().compare("/_lightTransform")==0) {
      //      cout <<"skip" << endl;
      //      continue;
      //    }
      osg::Node* newnode = createMirroredScene(node, ul, ur, ll, lr,
          mirrortexture, cutUpperHalf);

      rootTree_->replaceChild(node, newnode);
    }

  return;
}


void SceneOpenSceneGraph::
AddParticles()
{
  osgParticle::ParticleSystem *dustParticleSystem =
      new osgParticle::ParticleSystem;

  // Set the attributes 'texture', 'emmisive' and 'lighting'
  dustParticleSystem->setDefaultAttributes("/home/koeser/test.png", false,
      false);

  // Since the particle system is derived from the class Drawable, we can create
  // add it to the scene as a child of a geode
  osg::Geode *geode = new osg::Geode;
  osg::Group* rootNode = new osg::Group;
  rootNode->addChild(geode);
  geode->addDrawable(dustParticleSystem);

  // Add an 'updater' to help per-frame management
  osgParticle::ParticleSystemUpdater *dustSystemUpdater =
      new osgParticle::ParticleSystemUpdater;
  // Associate this updater with our particle system
  dustSystemUpdater->addParticleSystem(dustParticleSystem);
  // add the updater node to the scene graph
  rootNode->addChild(dustSystemUpdater);

  // Create a partical to be used by our particle system and define a few
  // of its properties
  osgParticle::Particle smokeParticle;
  smokeParticle.setSizeRange(osgParticle::rangef(0.01, 20.0)); // meters
  smokeParticle.setLifeTime(4); // seconds
  smokeParticle.setMass(0.01); // in kilograms
  // Make this our particle system's default particle
  dustParticleSystem->setDefaultParticleTemplate(smokeParticle);

  // Create a modular emitter (this contains default counter, placer and shooter.)
  osgParticle::ModularEmitter *emitter = new osgParticle::ModularEmitter;
  // Associate this emitter with the particle system
  emitter->setParticleSystem(dustParticleSystem);

  // Get a handle to the emitter's counter and adjust the number of new particles
  // that will be added each frame
  osgParticle::RandomRateCounter *dustRate =
      static_cast<osgParticle::RandomRateCounter *> (emitter->getCounter());
  dustRate->setRateRange(5, 10); // generate 5 to 10 particles per second

  // To customize the placer, create and initialize a multi-segment placer
  osgParticle::MultiSegmentPlacer* lineSegment =
      new osgParticle::MultiSegmentPlacer();
  // Add vertices to our placer. This defines line seqments along which our particles will
  // originate. (If we co-locate a tank and this emitter, this will result in dust particles
  // originating from a line extending below and behind the tank model.)
  lineSegment->addVertex(0, 0, -2);
  lineSegment->addVertex(0, -2, -2);
  lineSegment->addVertex(0, -16, 0);
  // Use this placer for our emitter
  emitter->setPlacer(lineSegment);

  // To customize the shooter, create and initialize a radial shooter
  osgParticle::RadialShooter* smokeShooter = new osgParticle::RadialShooter();
  // Set properties of this shooter
  smokeShooter->setThetaRange(0.0, 3.14159 / 2); // radians, relative to Z axis.
  smokeShooter->setInitialSpeedRange(50, 100); // meters/second
  // Use this shooter for our emitter
  emitter->setShooter(smokeShooter);

  //This section of code creates a modular program instance to control how particles are updated during their lifespan. The modular program applies operators to particles in the order the operators are added to the program.

  // Create a modular program and attach it to our particle system
  osgParticle::ModularProgram *moveDustInAir = new osgParticle::ModularProgram;
  moveDustInAir->setParticleSystem(dustParticleSystem);

  // Create an operator that simulates gravity, adjust it and add it to our program
  osgParticle::AccelOperator *accelUp = new osgParticle::AccelOperator;
  accelUp->setToGravity(-1); // scale factor for normal acceleration due to gravity.
  moveDustInAir->addOperator(accelUp);

  // Add an operator to our program to calculate the friction of air.
  osgParticle::FluidFrictionOperator *airFriction =
      new osgParticle::FluidFrictionOperator;
  airFriction->setFluidToAir();
  //airFriction->setFluidDensity(1.2929/*air*/*5.0f);
  moveDustInAir->addOperator(airFriction);

  // Finally, add the program to the scene
  rootNode->addChild(moveDustInAir);
  rootTree_->addChild(rootNode);
}