/**
* This method constructs an instance of TriMeshModel and stores it in
* CoinVisualizationNode::triMeshModel.
* If CoinVisualizationMode::visualization is invalid VirtualRobotException
* is thrown.
* Otherwise CoinVisualizationNode::InventorTriangleCB() is called on the
* Inventor graph stored in CoinVisualizationNode::visualization.
*/
void CoinVisualizationNode::createTriMeshModel()
{
THROW_VR_EXCEPTION_IF(!visualization, "CoinVisualizationNode::createTriMeshModel(): no Coin model present!");
if (triMeshModel)
triMeshModel->clear();
else
triMeshModel.reset(new TriMeshModel());
SoCallbackAction ca;
ca.addTriangleCallback(SoShape::getClassTypeId(), &CoinVisualizationNode::InventorTriangleCB, triMeshModel.get());
ca.apply(visualization);
}
void
IfReporter::reportNodeCount(const char *msg, SoNode *root)
{
if (! verbose)
return;
int nodeCount = 0;
SoCallbackAction cba;
cba.addPreCallback(SoNode::getClassTypeId(), countCB, &nodeCount);
cba.apply(root);
fprintf(fp, "%s: %d nodes\n", msg, nodeCount);
}
SoMaterial *
IfReplacer::createMaterialForPath(SoPath *path)
{
material = NULL;
// Apply an SoCallbackAction to the path, and create the material
// after we get to the tail node
SoCallbackAction cba;
cba.addPostTailCallback(materialTailCB, this);
cba.apply(path);
ASSERT(material != NULL);
return material;
}
PrimitiveData *
ShapeData::getPrimitives(void)
{
if (this->primitives) { return this->primitives; }
this->primitives = new PrimitiveData;
this->primitives->setPath(this->path);
this->primitives->transform = this->xfbbox.getTransform();
this->primitives->invtransform = primitives->transform.inverse();
SoCallbackAction generator;
generator.addTriangleCallback(SoShape::getClassTypeId(),
ShapeData::triangleCB,
this->primitives);
generator.apply(this->path);
return this->primitives;
}
void
countPrimitives(SoNode *root, int32_t &numTris, int32_t &numLines, int32_t &numPoints,
int32_t &numNodes)
//
////////////////////////////////////////////////////////////////////////
{
numTris = 0;
numLines = 0;
numPoints = 0;
numNodes = 0;
SoCallbackAction ca;
ca.addPointCallback(SoShape::getClassTypeId(),
countPointsCB,
(void *) &numPoints);
ca.addLineSegmentCallback(SoShape::getClassTypeId(),
countLinesCB,
(void *) &numLines);
ca.addTriangleCallback(SoShape::getClassTypeId(),
countTriangleCB,
(void *) &numTris);
ca.addPreCallback( SoNode::getClassTypeId(),
countNodesCB, (void *)&numNodes
);
ca.apply(root);
}
OSUInventorScene::OSUInventorScene(char *filename) {
SoSeparator *root = ReadScene(filename);
int numNodes = 0;
SoCallbackAction ca;
SoSearchAction SA;
SA.setType(SoLight::getClassTypeId(), TRUE);
SA.setInterest(SoSearchAction::ALL);
SA.apply(root);
SoPathList &paths = SA.getPaths();
#ifdef DEBUG
cerr << "There are " << paths.getLength() << " lights " << endl;
#endif
int i;
for (i = 0; i < paths.getLength(); i++) {
Lights.append(paths[i]->getTail()->copy());
}
SA.setType(SoCamera::getClassTypeId(), TRUE);
SA.setInterest(SoSearchAction::FIRST);
SA.apply(root);
if (SA.getPath()) {
Camera = (SoCamera *)SA.getPath()->getTail()->copy();
#ifdef DEBUG
cerr << "Found a camera!\n";
#endif
} else
Camera = NULL;
ca.addPreCallback(SoNode::getClassTypeId(), processNodesCB, (void *)
&Objects);
ca.apply(root);
// Now lets find the lights and camera!
//
#ifdef DEBUG
cerr << "There are " << Objects.getLength() << " shape objects left!\n";
#endif
}
void
Scene::load(const ::std::string& filename, const bool& doBoundingBoxPoints, const bool& doPoints)
{
::rl::xml::DomParser parser;
::rl::xml::Document doc = parser.readFile(filename, "", XML_PARSE_NOENT | XML_PARSE_XINCLUDE);
doc.substitute(XML_PARSE_NOENT | XML_PARSE_XINCLUDE);
::rl::xml::Path path(doc);
::rl::xml::Object scenes = path.eval("//scene");
for (int i = 0; i < ::std::min(1, scenes.getNodeNr()); ++i)
{
SoInput input;
if (!input.openFile(scenes.getNodeTab(i).getLocalPath(scenes.getNodeTab(i).getAttribute("href").getValue()).c_str() ,true))
{
throw Exception("::rl::sg::Scene::load() - failed to open file");
}
SoVRMLGroup* root = SoDB::readAllVRML(&input);
if (NULL == root)
{
throw Exception("::rl::sg::Scene::load() - failed to read file");
}
SbViewportRegion viewportRegion;
root->ref();
// model
::rl::xml::Object models = path.eval("model", scenes.getNodeTab(i));
for (int j = 0; j < models.getNodeNr(); ++j)
{
SoSearchAction modelSearchAction;
modelSearchAction.setName(models.getNodeTab(j).getAttribute("name").getValue().c_str());
modelSearchAction.apply(root);
if (NULL == modelSearchAction.getPath())
{
continue;
}
Model* model = this->create();
model->setName(models.getNodeTab(j).getAttribute("name").getValue());
// body
::rl::xml::Object bodies = path.eval("body", models.getNodeTab(j));
for (int k = 0; k < bodies.getNodeNr(); ++k)
{
SoSearchAction bodySearchAction;
bodySearchAction.setName(bodies.getNodeTab(k).getAttribute("name").getValue().c_str());
bodySearchAction.apply(static_cast< SoFullPath* >(modelSearchAction.getPath())->getTail());
if (NULL == bodySearchAction.getPath())
{
continue;
}
Body* body = model->create();
body->setName(bodies.getNodeTab(k).getAttribute("name").getValue());
SoSearchAction pathSearchAction;
pathSearchAction.setNode(static_cast< SoFullPath* >(bodySearchAction.getPath())->getTail());
pathSearchAction.apply(root);
SoGetMatrixAction bodyGetMatrixAction(viewportRegion);
bodyGetMatrixAction.apply(static_cast< SoFullPath* >(pathSearchAction.getPath()));
SbMatrix bodyMatrix = bodyGetMatrixAction.getMatrix();
if (!this->isScalingSupported)
{
SbVec3f bodyTranslation;
SbRotation bodyRotation;
SbVec3f bodyScaleFactor;
SbRotation bodyScaleOrientation;
SbVec3f bodyCenter;
bodyMatrix.getTransform(bodyTranslation, bodyRotation, bodyScaleFactor, bodyScaleOrientation, bodyCenter);
for (int l = 0; l < 3; ++l)
{
if (::std::abs(bodyScaleFactor[l] - 1.0f) > 1.0e-6f)
{
throw Exception("::rl::sg::Scene::load() - bodyScaleFactor not supported");
}
}
}
::rl::math::Transform frame;
for (int m = 0; m < 4; ++m)
{
for (int n = 0; n < 4; ++n)
{
frame(m, n) = bodyMatrix[n][m];
}
}
body->setFrame(frame);
if (static_cast< SoFullPath* >(bodySearchAction.getPath())->getTail()->isOfType(SoVRMLTransform::getClassTypeId()))
{
SoVRMLTransform* bodyVrmlTransform = static_cast< SoVRMLTransform* >(static_cast< SoFullPath* >(bodySearchAction.getPath())->getTail());
for (int l = 0; l < 3; ++l)
{
body->center(l) = bodyVrmlTransform->center.getValue()[l];
}
}
SoPathList pathList;
// shape
SoSearchAction shapeSearchAction;
shapeSearchAction.setInterest(SoSearchAction::ALL);
shapeSearchAction.setType(SoVRMLShape::getClassTypeId());
shapeSearchAction.apply(static_cast< SoFullPath* >(bodySearchAction.getPath())->getTail());
for (int l = 0; l < shapeSearchAction.getPaths().getLength(); ++l)
{
SoFullPath* path = static_cast< SoFullPath* >(shapeSearchAction.getPaths()[l]);
if (path->getLength() > 1)
{
path = static_cast< SoFullPath* >(shapeSearchAction.getPaths()[l]->copy(1, static_cast< SoFullPath* >(shapeSearchAction.getPaths()[l])->getLength() - 1));
}
pathList.append(path);
SoGetMatrixAction shapeGetMatrixAction(viewportRegion);
shapeGetMatrixAction.apply(path);
SbMatrix shapeMatrix = shapeGetMatrixAction.getMatrix();
if (!this->isScalingSupported)
{
SbVec3f shapeTranslation;
SbRotation shapeRotation;
SbVec3f shapeScaleFactor;
SbRotation shapeScaleOrientation;
SbVec3f shapeCenter;
shapeMatrix.getTransform(shapeTranslation, shapeRotation, shapeScaleFactor, shapeScaleOrientation, shapeCenter);
for (int m = 0; m < 3; ++m)
{
if (::std::abs(shapeScaleFactor[m] - 1.0f) > 1.0e-6f)
{
throw Exception("::rl::sg::Scene::load() - shapeScaleFactor not supported");
}
}
}
SoVRMLShape* shapeVrmlShape = static_cast< SoVRMLShape* >(static_cast< SoFullPath* >(shapeSearchAction.getPaths()[l])->getTail());
Shape* shape = body->create(shapeVrmlShape);
shape->setName(shapeVrmlShape->getName().getString());
::rl::math::Transform transform;
for (int m = 0; m < 4; ++m)
{
for (int n = 0; n < 4; ++n)
{
transform(m, n) = shapeMatrix[n][m];
}
}
shape->setTransform(transform);
}
// bounding box
if (doBoundingBoxPoints)
{
SoGetBoundingBoxAction getBoundingBoxAction(viewportRegion);
getBoundingBoxAction.apply(pathList);
SbBox3f boundingBox = getBoundingBoxAction.getBoundingBox();
for (int l = 0; l < 3; ++l)
{
body->max(l) = boundingBox.getMax()[l];
body->min(l) = boundingBox.getMin()[l];
}
}
// convex hull
if (doPoints)
{
SoCallbackAction callbackAction;
callbackAction.addTriangleCallback(SoVRMLGeometry::getClassTypeId(), Scene::triangleCallback, &body->points);
callbackAction.apply(pathList);
}
}
}
root->unref();
}
}
