void
CountsVisitor::apply(osg::Transform& node)
{
pushStateSet(node.getStateSet());
if (dynamic_cast<osgSim::DOFTransform*>(&node) != NULL)
{
_dofTransforms++;
osg::ref_ptr<osg::Object> rp = (osg::Object*)&node;
_uDofTransforms.insert(rp);
}
else
{
_transforms++;
osg::ref_ptr<osg::Object> rp = (osg::Object*)&node;
_uTransforms.insert(rp);
}
_totalChildren += node.getNumChildren();
apply(node.getStateSet());
if (++_depth > _maxDepth)
_maxDepth = _depth;
traverse((osg::Node&)node);
_depth--;
popStateSet();
}
void StatsVisitor::apply(osg::Transform& node)
{
if (node.getStateSet())
{
apply(*node.getStateSet());
}
++_numInstancedTransform;
_transformSet.insert(&node);
traverse(node);
}
OSG::Action::ResultE dontEnterTrans(OSG::Node *node)
{
SLOG << "entering " << node << OSG::endLog;
if(node->getCore()->getType().isDerivedFrom(OSG::Transform::getClassType()))
{
OSG::Transform *t = dynamic_cast<OSG::Transform *>(node->getCore());
SLOG << "derived from transform, skipping children" << OSG::endLog;
SLOG << "Matrix: " << OSG::endLog << t->getMatrix();
return OSG::Action::Skip;
}
return OSG::Action::Continue;
}
void ComputeBoundingBoxVisitor::apply(osg::Transform& node)
{
if(node.asMatrixTransform() || node.asPositionAttitudeTransform())
{
osg::Matrix prevMatrix = m_curMatrix;
//m_curMatrix.preMult(node.asMatrixTransform()->getMatrix());
node.computeLocalToWorldMatrix(m_curMatrix,this);
traverse(node);
m_curMatrix = prevMatrix;
}
}
void CURRENT_CLASS::apply(osg::Transform &transform)
{
if(shouldContinueTraversal(transform))
{
// Compute transform for current node
osg::Matrix currMatrix = _viewMatrices.back();
bool pushMatrix = transform.computeLocalToWorldMatrix(currMatrix,this);
if(pushMatrix)
{
// Store the new modelview matrix and view frustum
_viewMatrices.push_back(currMatrix);
pushLocalFrustum();
}
++_currentDepth;
traverse(transform);
--_currentDepth;
if(pushMatrix)
{
// Restore the old modelview matrix and view frustum
_localFrusta.pop_back();
_bbCorners.pop_back();
_viewMatrices.pop_back();
}
}
}
void
FltExportVisitor::apply( osg::Transform& node )
{
_firstNode = false;
ScopedStatePushPop guard( this, node.getStateSet() );
osgSim::DOFTransform* dof = dynamic_cast<osgSim::DOFTransform*>( &node );
if (dof)
{
writeDegreeOfFreedom( dof);
}
writeMatrix( node.getUserData() );
writeComment( node );
writePushTraverseWritePop( node );
}
void ComputeTrianglesVisitor::apply( osg::Transform& node )
{
osg::Matrix matrix = _matrixStack.back();
node.computeLocalToWorldMatrix( matrix, this );
_matrixStack.push_back( matrix );
traverse( node );
_matrixStack.pop_back();
}
void
BuildTopologyVisitor::apply(osg::Transform& xform)
{
osg::Matrix matrix;
if (!_matrixStack.empty()) matrix = _matrixStack.back();
xform.computeLocalToWorldMatrix(matrix, this);
_matrixStack.push_back(matrix);
traverse(xform);
_matrixStack.pop_back();
}
void apply(osg::Transform &node)
{
osg::MatrixTransform* bone = node.asMatrixTransform();
if (!bone)
return;
mCache[Misc::StringUtils::lowerCase(bone->getName())] = std::make_pair(getNodePath(), bone);
traverse(node);
}
void GeometryDataCollector::apply( osg::Transform& transform )
{
osg::Matrix matrix;
if ( !matrixStack.empty() ) matrix = matrixStack.back();
transform.computeLocalToWorldMatrix( matrix, this );
pushMatrix( matrix );
traverse( transform );
popMatrix();
}
void
GeometryClamper::apply(osg::Transform& xform)
{
osg::Matrixd matrix;
if ( !_matrixStack.empty() ) matrix = _matrixStack.back();
xform.computeLocalToWorldMatrix( matrix, this );
_matrixStack.push_back( matrix );
traverse(xform);
_matrixStack.pop_back();
}
void apply(osg::Transform &node)
{
osg::MatrixTransform* bone = node.asMatrixTransform();
if (!bone)
return;
mCache[bone->getName()] = std::make_pair(getNodePath(), bone);
traverse(node);
}
void CollectOccludersVisitor::apply(osg::Transform &node)
{
if (isCulled(node))
return;
// push the culling mode.
pushCurrentMask();
ref_ptr<osg::RefMatrix> matrix = createOrReuseMatrix(*getModelViewMatrix());
node.computeLocalToWorldMatrix(*matrix, this);
pushModelViewMatrix(matrix.get(), node.getReferenceFrame());
handle_cull_callbacks_and_traverse(node);
popModelViewMatrix();
// pop the culling mode.
popCurrentMask();
}
void
ProxyCullVisitor::apply(osg::Transform& node)
{
//OE_INFO << "Transform!" << std::endl;
if ( isCulledByProxyFrustum(node) )
return;
_cv->pushOntoNodePath( &node);
_cv->pushCurrentMask();
osg::StateSet* node_state = node.getStateSet();
if (node_state) _cv->pushStateSet(node_state);
// push the current proxy data:
osg::Polytope savedF = _proxyFrustum;
osg::Matrix savedMV = _proxyModelViewMatrix;
// calculate the new proxy frustum:
node.computeLocalToWorldMatrix(_proxyModelViewMatrix, this);
_proxyFrustum.setAndTransformProvidingInverse( _proxyProjFrustum, _proxyModelViewMatrix );
osg::ref_ptr<osg::RefMatrix> matrix = createOrReuseMatrix(*_cv->getModelViewMatrix());
node.computeLocalToWorldMatrix(*matrix,this);
_cv->pushModelViewMatrix(matrix.get(), node.getReferenceFrame());
// traverse children:
handle_cull_callbacks_and_traverse(node);
// restore the previous proxy frustum and MVM
_proxyFrustum = savedF;
_proxyModelViewMatrix = savedMV;
_cv->popModelViewMatrix();
if (node_state) _cv->popStateSet();
_cv->popCurrentMask();
_cv->popFromNodePath();
}
void apply(osg::Transform& transform)
{
osg::Matrix matrix;
if (!_matrixStack.empty()) matrix = _matrixStack.back();
transform.computeLocalToWorldMatrix(matrix,this);
pushMatrix(matrix);
traverse(transform);
popMatrix();
}
void CVRCullVisitor::apply(osg::Transform& node)
{
bool status = _cullingStatus;
bool firstStatus = _firstCullStatus;
if(isCulled(node))
{
_firstCullStatus = firstStatus;
_cullingStatus = status;
return;
}
// push the culling mode.
pushCurrentMask();
// push the node's state.
StateSet* node_state = node.getStateSet();
if(node_state)
pushStateSet(node_state);
ref_ptr<RefMatrix> matrix = createOrReuseMatrix(*getModelViewMatrix());
node.computeLocalToWorldMatrix(*matrix,this);
pushModelViewMatrix(matrix.get(),node.getReferenceFrame());
handle_cull_callbacks_and_traverse(node);
popModelViewMatrix();
// pop the node's state off the render graph stack.
if(node_state)
popStateSet();
// pop the culling mode.
popCurrentMask();
_firstCullStatus = firstStatus;
_cullingStatus = status;
}
void ComputeCylinderVisitor::apply( osg::Transform & transform )
{
osg::Matrix matrix;
if( !stack.empty() )
{
matrix = stack.back();
}
transform.computeLocalToWorldMatrix( matrix, this );
pushMatrix( matrix );
traverse( transform );
popMatrix();
}
void IntersectionVisitor::apply(osg::Transform& transform)
{
if (!enter(transform)) return;
osg::ref_ptr<osg::RefMatrix> matrix = _modelStack.empty() ? new osg::RefMatrix() : new osg::RefMatrix(*_modelStack.back());
transform.computeLocalToWorldMatrix(*matrix,this);
pushModelMatrix(matrix.get());
// now push an new intersector clone transform to the new local coordinates
push_clone();
traverse(transform);
// pop the clone.
pop_clone();
popModelMatrix();
// tidy up an cached cull variables in the current intersector.
leave();
}
void daeWriter::apply( osg::Transform &node )
{
debugPrint( node );
updateCurrentDaeNode();
currentNode = daeSafeCast< domNode >(currentNode->add( COLLADA_ELEMENT_NODE ) );
// If a DOFTransform node store it's data as extra "DOFTransform" data in the "OpenSceneGraph" technique
osgSim::DOFTransform* dof = dynamic_cast<osgSim::DOFTransform*>(&node);
if (_pluginOptions.writeExtras && dof)
{
// Adds the following to a node
//<extra type="DOFTransform">
// <technique profile="OpenSceneGraph">
// <MinHPR>0 -0.174533 0</MinHPR>
// <MaxHPR>0 0.872665 0</MaxHPR>
// <IncrementHPR>0 0.0174533 0</IncrementHPR>
// <CurrentHPR>0 0 0</CurrentHPR>
// <MinTranslate>0 0 0</MinTranslate>
// <MaxTranslate>0 0 0</MaxTranslate>
// <IncrementTranslate>0 0 0</IncrementTranslate>
// <CurrentTranslate>0 0 0</CurrentTranslate>
// <MinScale>0 0 0</MinScale>
// <MaxScale>1 1 1</MaxScale>
// <IncrementScale>0 0 0</IncrementScale>
// <CurrentScale>1 1 1</CurrentScale>
// <MultOrder>0</MultOrder>
// <LimitationFlags>269964960</LimitationFlags>
// <AnimationOn>0</AnimationOn>
// <PutMatrix>
// 1 0 0 0
// 0 1 0 0
// 0 0 1 0
// 0 0 0 1
// </PutMatrix>
// </technique>
//</extra>
domExtra *extra = daeSafeCast<domExtra>(currentNode->add( COLLADA_ELEMENT_EXTRA ));
extra->setType("DOFTransform");
domTechnique *teq = daeSafeCast<domTechnique>(extra->add( COLLADA_ELEMENT_TECHNIQUE ) );
teq->setProfile( "OpenSceneGraph" );
domAny *minHPR = (domAny*)teq->add("MinHPR" );
minHPR->setValue(toString(dof->getMinHPR()).c_str());
domAny *maxHPR = (domAny*)teq->add("MaxHPR" );
maxHPR->setValue(toString(dof->getMaxHPR()).c_str());
domAny *incrementHPR = (domAny*)teq->add("IncrementHPR" );
incrementHPR->setValue(toString(dof->getIncrementHPR()).c_str());
domAny *currentHPR = (domAny*)teq->add("CurrentHPR" );
currentHPR->setValue(toString(dof->getCurrentHPR()).c_str());
domAny *minTranslate = (domAny*)teq->add("MinTranslate" );
minTranslate->setValue(toString(dof->getMinTranslate()).c_str());
domAny *maxTranslate = (domAny*)teq->add("MaxTranslate" );
maxTranslate->setValue(toString(dof->getMaxTranslate()).c_str());
domAny *incrementTranslate = (domAny*)teq->add("IncrementTranslate" );
incrementTranslate->setValue(toString(dof->getIncrementTranslate()).c_str());
domAny *currentTranslate = (domAny*)teq->add("CurrentTranslate" );
currentTranslate->setValue(toString(dof->getCurrentTranslate()).c_str());
domAny *minScale = (domAny*)teq->add("MinScale" );
minScale->setValue(toString(dof->getMinScale()).c_str());
domAny *maxScale = (domAny*)teq->add("MaxScale" );
maxScale->setValue(toString(dof->getMaxScale()).c_str());
domAny *incrementScale = (domAny*)teq->add("IncrementScale" );
incrementScale->setValue(toString(dof->getIncrementScale()).c_str());
domAny *currentScale = (domAny*)teq->add("CurrentScale" );
currentScale->setValue(toString(dof->getCurrentScale()).c_str());
domAny *multOrder = (domAny*)teq->add("MultOrder" );
multOrder->setValue(toString<int>(dof->getHPRMultOrder()).c_str());
domAny *limitationFlags = (domAny*)teq->add("LimitationFlags" );
limitationFlags->setValue(toString<unsigned long>(dof->getLimitationFlags()).c_str());
domAny *animationOn = (domAny*)teq->add("AnimationOn" );
animationOn->setValue(toString<bool>(dof->getAnimationOn()).c_str());
domAny *putMatrix = (domAny*)teq->add("PutMatrix" );
putMatrix->setValue(toString(dof->getPutMatrix()).c_str());
currentNode->setId(getNodeName(node, "doftransform").c_str());
}
else
{
osgAnimation::Bone* bone = dynamic_cast<osgAnimation::Bone*>(&node);
if (bone)
{
domNode *pDomNode = daeSafeCast< domNode >(currentNode->add( COLLADA_ELEMENT_NODE ));
pDomNode->setType(NODETYPE_JOINT);
pDomNode->setId(getNodeName(node, "bone").c_str());
}
else
{
std::string nodeName = getNodeName(node, "transform");
currentNode->setId(nodeName.c_str());
// Unknown transform type, just use local to world matrix
osg::Matrix matrix;
node.computeLocalToWorldMatrix(matrix, NULL);
osg::Callback* ncb = node.getUpdateCallback();
bool handled = false;
if (ncb)
{
osgAnimation::UpdateMatrixTransform* ut = dynamic_cast<osgAnimation::UpdateMatrixTransform*>(ncb);
// If targeted by an animation we split up the matrix into multiple place element so they can be targeted individually
if (ut)
{
handled = true;
// Note: though this is a generic matrix, based on the fact that it will be animated by and UpdateMatrixTransform,
// we assume the initial matrix can be decomposed into translation, rotation and scale elements
writeUpdateTransformElements(matrix.getTrans(), matrix.getRotate(), matrix.getScale());
}
}
// If not targeted by an animation simply write a single matrix place element
if (!handled)
{
domMatrix *mat = daeSafeCast< domMatrix >(currentNode->add( COLLADA_ELEMENT_MATRIX ) );
nodeName += "_matrix";
mat->setSid(nodeName.c_str());
const osg::Matrix::value_type *mat_vals = matrix.ptr();
for ( int i = 0; i < 4; i++ )
{
for ( int j = 0; j < 4; j++ )
{
mat->getValue().append( mat_vals[i + j*4] );
}
}
}
}
}
writeNodeExtra(node);
lastDepth = _nodePath.size();
traverse( node );
}
void daeWriter::apply( osg::Transform &node )
{
osg::notify( osg::WARN ) << "some other transform type. Missing " << node.getNumChildren() << " children\n";
}
void printXForm(OSG::SceneGraphPrinter *sgp, OSG::NodeCore *core)
{
OSG::Transform *xform = dynamic_cast<OSG::Transform *>(core);
sgp->indentStream() << "matrix:\n" << xform->getMatrix();
}