void visit(const scene::INodePtr& node) const {
ASSERT_MESSAGE(_count <= _max, "Invalid _count in CollectSelectedBrushesBounds");
// stop if the array is already full
if (_count == _max) {
return;
}
if (Node_isSelected(node) && Node_isBrush(node)) {
_bounds[_count] = node->worldAABB();
++_count;
}
}
void ModelExporter::processNodes()
{
AABB bounds = calculateModelBounds();
if (_centerObjects)
{
// Depending on the center point, we need to use the object bounds
// or just the translation towards the user-defined origin, ignoring bounds
_centerTransform = _useOriginAsCenter ?
Matrix4::getTranslation(-_origin) :
Matrix4::getTranslation(-bounds.origin);
}
for (const scene::INodePtr& node : _nodes)
{
if (Node_isModel(node))
{
model::ModelNodePtr modelNode = Node_getModel(node);
// Push the geometry into the exporter
model::IModel& model = modelNode->getIModel();
Matrix4 exportTransform = node->localToWorld().getPremultipliedBy(_centerTransform);
for (int s = 0; s < model.getSurfaceCount(); ++s)
{
const model::IModelSurface& surface = model.getSurface(s);
if (isExportableMaterial(surface.getActiveMaterial()))
{
_exporter->addSurface(surface, exportTransform);
}
}
}
else if (Node_isBrush(node))
{
processBrush(node);
}
else if (Node_isPatch(node))
{
processPatch(node);
}
else if (_exportLightsAsObjects && Node_getLightNode(node))
{
processLight(node);
}
}
}
AABB ModelExporter::calculateModelBounds()
{
AABB bounds;
for (const scene::INodePtr& node : _nodes)
{
// Only consider the node types supported by processNodes()
if (!Node_isModel(node) && !Node_isBrush(node) && !Node_isPatch(node))
{
continue;
}
bounds.includeAABB(node->worldAABB());
}
return bounds;
}
bool pre( scene::Node& node ) const {
scene::Path path( NodeReference( GlobalSceneGraph().root() ) );
path.push( NodeReference( *m_entity->QER_Entity ) );
path.push( NodeReference( node ) );
scene::Instance* instance = GlobalSceneGraph().find( path );
ASSERT_MESSAGE( instance != 0, "" );
if ( Node_isPatch( node ) ) {
DPatch* loadPatch = m_entity->NewPatch();
loadPatch->LoadFromPatch( *instance );
}
else if ( Node_isBrush( node ) ) {
DBrush* loadBrush = m_entity->NewBrush( m_count++ );
loadBrush->LoadFromBrush( *instance, true );
}
return false;
}
bool pre(const scene::Path& path, scene::Instance& instance) const {
if (path.top().get().visible() && Node_isBrush(path.top())) // this node is a floor
{
const AABB& aabb = instance.worldAABB();
float floorHeight = aabb.origin.z() + aabb.extents.z();
if (floorHeight > m_current && floorHeight < m_bestUp) {
m_bestUp = floorHeight;
}
if (floorHeight < m_current && floorHeight > m_bestDown) {
m_bestDown = floorHeight;
}
}
return true;
}
void visit( scene::Instance& instance ) const {
if ( Node_isBrush( instance.path().top() ) ) {
m_functor( instance );
}
}
bool contains_entity (scene::Node& node) const
{
return Node_getTraversable(node) != 0 && !Node_isBrush(node) && !Node_isEntity(node);
}
