void
IfWeeder::findMaterialsAndShapes(SoNode *root)
{
// Since we know the structure of the given scene graph (which is
// after fixing has occurred), we can be efficient here. Just
// search for all materials in the scene. For each material, the
// shapes affected by it must be under the separator that is the
// material's parent node. So just search for all shapes under
// that separator, making sure that the path to the shape comes
// after the material.
// First, create a dictionary so we can tell when we've found a
// multiple instance of a material
SbDict materialDict;
// Search for all materials in the scene
SoSearchAction sa;
sa.setType(SoMaterial::getClassTypeId());
sa.setInterest(SoSearchAction::ALL);
sa.apply(root);
// Set up another search action to find all shapes using a
// material. Note that we have to search for all node types that
// should be considered shapes.
SoSearchAction sa2;
sa2.setInterest(SoSearchAction::ALL);
// These are the shape types
SoTypeList shapeTypes;
IfTypes::getShapeTypes(&shapeTypes);
// Process each material, adding new ones to the list
materialList = new SbPList;
for (int i = 0; i < sa.getPaths().getLength(); i++) {
const SoPath *path = (const SoPath *) sa.getPaths()[i];
ASSERT(path->getLength() > 1);
ASSERT(path->getTail()->getTypeId() == SoMaterial::getClassTypeId());
SoMaterial *material = (SoMaterial *) path->getTail();
// Add to the dictionary if necessary, or use the existing
// entry
void *entryPtr;
IfWeederMaterialEntry *entry;
if (materialDict.find((unsigned long) material, entryPtr)) {
entry = (IfWeederMaterialEntry *) entryPtr;
if (! entry->canWeed)
continue;
}
else {
entry = new IfWeederMaterialEntry;
entry->material = material;
entry->canWeed = TRUE;
materialDict.enter((unsigned long) material, entry);
materialList->append(entry);
}
// If any node above the material in the path is an opaque
// group, we can't really weed this material
int j;
for (j = path->getLength() - 2; j >= 0; j--) {
if (IfTypes::isOpaqueGroupType(path->getNode(j)->getTypeId())) {
entry->canWeed = FALSE;
break;
}
}
if (! entry->canWeed)
continue;
ASSERT(path->getNodeFromTail(1)->
isOfType(SoSeparator::getClassTypeId()));
SoSeparator *parent = (SoSeparator *) path->getNodeFromTail(1);
int materialIndex = path->getIndexFromTail(0);
// Find all shapes using the material, adding them to the list
// of shapes in the material's entry. Store all the paths to
// them in this list
SoPathList pathsToShapes;
for (int type = 0; type < shapeTypes.getLength(); type++) {
sa2.setType(shapeTypes[type]);
sa2.apply(parent);
for (j = 0; j < sa2.getPaths().getLength(); j++)
pathsToShapes.append(sa2.getPaths()[j]);
}
for (j = 0; j < pathsToShapes.getLength(); j++) {
const SoPath *shapePath = (const SoPath *) pathsToShapes[j];
// We can't weed the material at all if a shape other than
// the one we created is found
SoType tailType = shapePath->getTail()->getTypeId();
if (tailType != SoIndexedTriangleStripSet::getClassTypeId() &&
tailType != SoIndexedFaceSet::getClassTypeId()) {
entry->canWeed = FALSE;
break;
}
// Make sure the shape comes after the material and does
// not get its materials from a vertex property
// node.
else if (shapePath->getIndex(1) > materialIndex) {
SoIndexedShape *is = (SoIndexedShape *) shapePath->getTail();
// ??? If the shape's materialIndex field has the
// ??? default value, we assume that it might have to
// ??? access all the material values. To check, we would
// ??? have to look at the coordIndex values if the
// ??? material binding is not OVERALL. This change could
// ??? not be done in time for the release. See bug 311071.
if (is->materialIndex.getNum() == 1 &&
is->materialIndex[0] < 0) {
entry->canWeed = FALSE;
break;
}
SoVertexProperty *vp =
(SoVertexProperty *) is->vertexProperty.getValue();
if (vp == NULL || vp->orderedRGBA.getNum() == 0)
entry->shapes.append(shapePath->getTail());
}
}
}
}
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();
}
}
