bool pre(const scene::INodePtr& node) {
// Don't traverse hidden nodes
if (!node->visible()) {
return false;
}
SelectablePtr selectable = Node_getSelectable(node);
// ignore worldspawn
Entity* entity = Node_getEntity(node);
if (entity != NULL) {
if (entity->getKeyValue("classname") == "worldspawn") {
return true;
}
}
bool selected = false;
if (selectable != NULL && node->getParent() != NULL && !node->isRoot()) {
for (std::size_t i = 0; i < _count; ++i) {
// Check if the selectable passes the AABB test
if (policy.evaluate(_aabbs[i], node)) {
selectable->setSelected(true);
selected = true;
break;
}
}
}
// Only traverse the children of this node, if the node itself couldn't be selected
return !selected;
}
void GraphTreeModel::updateSelectionStatus(const scene::INodePtr& node,
const NotifySelectionUpdateFunc& notifySelectionChanged)
{
NodeMap::const_iterator found = _nodemap.find(scene::INodeWeakPtr(node));
GraphTreeNodePtr foundNode;
if (found == _nodemap.end())
{
// The node is not in our map, it might have been previously hidden
if (node->visible())
{
foundNode = insert(node);
}
}
else
{
foundNode = found->second;
}
if (foundNode)
{
notifySelectionChanged(foundNode->getIter(), Node_isSelected(node));
}
}
void visit(const scene::INodePtr& node) const {
BrushNodePtr brush = std::dynamic_pointer_cast<BrushNode>(node);
if (brush != NULL && node->visible()) {
brush->setClipPlane(_plane);
}
}
bool pre(const scene::INodePtr& node) {
SelectablePtr selectable = Node_getSelectable(node);
// If a visible selectable was found and the path depth is appropriate, add it
if (selectable != NULL && node->visible()) {
_targetList.push_back(node);
}
return true;
}
void PlaneSelectableSelectPlanes::visit(const scene::INodePtr& node) const {
// Skip hidden nodes
if (!node->visible()) {
return;
}
PlaneSelectablePtr planeSelectable = Node_getPlaneSelectable(node);
if (planeSelectable != NULL) {
planeSelectable->selectPlanes(_selector, _test, _selectedPlaneCallback);
}
}
bool pre(const scene::INodePtr& node) {
if (node->visible()) {
Brush* brush = Node_getBrush(node);
if (brush != NULL && brush->hasShader(_name)) {
Node_setSelected(node, true);
return false; // don't traverse brushes
}
// not a suitable brush, traverse further
return true;
}
else {
return false; // don't traverse invisible nodes
}
}
bool pre(const scene::INodePtr& node)
{
// Ignore hidden nodes
if (!node->visible()) return false;
Entity* entity = Node_getEntity(node);
// Check if we have a selectable
SelectablePtr selectable = Node_getSelectable(node);
if (selectable != NULL)
{
switch (_mode)
{
case SelectionSystem::eEntity:
if (entity != NULL && entity->getKeyValue("classname") != "worldspawn")
{
_selectable = selectable;
}
break;
case SelectionSystem::ePrimitive:
_selectable = selectable;
break;
case SelectionSystem::eComponent:
// Check if we have a componentselectiontestable instance
ComponentSelectionTestablePtr compSelTestable =
Node_getComponentSelectionTestable(node);
// Only add it to the list if the instance has components and is already selected
if (compSelTestable != NULL && selectable->isSelected())
{
_selectable = selectable;
}
break;
}
}
// Do we have a groupnode? If yes, don't traverse the children
if (entity != NULL && node_is_group(node) &&
entity->getKeyValue("classname") != "worldspawn")
{
// Don't traverse the children of this groupnode
return false;
}
return true;
}
bool EntitySelectByClassnameWalker::pre(const scene::INodePtr& node) {
// don't traverse invisible nodes
if (!node->visible()) return false;
Entity* entity = Node_getEntity(node);
if (entity != NULL) {
if (entityMatches(entity)) {
// Got a matching entity
Node_setSelected(node, true);
}
// Don't traverse entities
return false;
}
// Not an entity, traverse
return true;
}
// The visitor function
bool pre(const scene::INodePtr& node) {
// Check if the node is filtered
if (node->visible()) {
SelectionTestablePtr selectionTestable = Node_getSelectionTestable(node);
if (selectionTestable != NULL) {
bool occluded;
OccludeSelector selector(_bestIntersection, occluded);
selectionTestable->testSelect(selector, _selectionTest);
if (occluded) {
_node = node;
}
}
}
else {
return false; // don't traverse filtered nodes
}
return true;
}
void GraphTreeModel::updateSelectionStatus(const Glib::RefPtr<Gtk::TreeSelection>& selection, const scene::INodePtr& node)
{
NodeMap::const_iterator found = _nodemap.find(scene::INodeWeakPtr(node));
GraphTreeNodePtr foundNode;
if (found == _nodemap.end())
{
// The node is not in our map, it might have been previously hidden
if (node->visible())
{
foundNode = insert(node);
}
}
else
{
foundNode = found->second;
}
if (foundNode)
{
if (Node_isSelected(node))
{
// Select the row in the TreeView
selection->select(foundNode->getIter());
// Scroll to the row
Gtk::TreeView* tv = selection->get_tree_view();
Gtk::TreeModel::Path selectedPath(foundNode->getIter());
tv->expand_to_path(selectedPath);
tv->scroll_to_row(selectedPath, 0.3f);
}
else
{
selection->unselect(foundNode->getIter());
}
}
}
bool pre(const scene::INodePtr& node) {
if (!node->visible()) return false; // don't traverse hidden nodes
if (Node_isBrush(node)) // this node is a floor
{
const AABB& aabb = node->worldAABB();
float floorHeight = aabb.origin.z() + aabb.extents.z();
if (floorHeight > _current && floorHeight < _bestUp) {
_bestUp = floorHeight;
}
if (floorHeight < _current && floorHeight > _bestDown) {
_bestDown = floorHeight;
}
return false;
}
return true;
}
void BrushByPlaneClipper::visit(const scene::INodePtr& node) const {
// Don't clip invisible nodes
if (!node->visible()) {
return;
}
// Try to cast the instance onto a brush
Brush* brush = Node_getBrush(node);
// Return if not brush
if (brush == NULL) {
return;
}
Plane3 plane(_p0, _p1, _p2);
if (!plane.isValid()) {
return;
}
// greebo: Analyse the brush to find out which shader is the most used one
getMostUsedTexturing(brush);
BrushSplitType split = Brush_classifyPlane(*brush, _split == eFront ? -plane : plane);
if (split.counts[ePlaneBack] && split.counts[ePlaneFront]) {
// the plane intersects this brush
if (_split == eFrontAndBack) {
scene::INodePtr brushNode = GlobalBrushCreator().createBrush();
assert(brushNode != NULL);
Brush* fragment = Node_getBrush(brushNode);
assert(fragment != NULL);
fragment->copy(*brush);
FacePtr newFace = fragment->addPlane(_p0, _p1, _p2, _mostUsedShader, _mostUsedProjection);
if (newFace != NULL && _split != eFront) {
newFace->flipWinding();
}
fragment->removeEmptyFaces();
ASSERT_MESSAGE(!fragment->empty(), "brush left with no faces after split");
// Mark this brush for insertion
_insertList.insert(InsertMap::value_type(brushNode, node->getParent()));
}
FacePtr newFace = brush->addPlane(_p0, _p1, _p2, _mostUsedShader, _mostUsedProjection);
if (newFace != NULL && _split == eFront) {
newFace->flipWinding();
}
brush->removeEmptyFaces();
ASSERT_MESSAGE(!brush->empty(), "brush left with no faces after split");
}
// the plane does not intersect this brush
else if (_split != eFrontAndBack && split.counts[ePlaneBack] != 0) {
// the brush is "behind" the plane
_deleteList.insert(node);
}
}
void post(const scene::INodePtr& node) {
if (!node->visible()) {
return;
}
Brush* brush = Node_getBrush(node);
if (brush != NULL && !Node_isSelected(node))
{
BrushNodePtr brushNode = std::dynamic_pointer_cast<BrushNode>(node);
// Get the parent of this brush
scene::INodePtr parent = node->getParent();
assert(parent != NULL); // parent should not be NULL
BrushPtrVector buffer[2];
std::size_t swap = 0;
BrushNodePtr original = std::dynamic_pointer_cast<BrushNode>(brushNode->clone());
//Brush* original = new Brush(*brush);
buffer[swap].push_back(original);
// Iterate over all selected brushes
for (BrushPtrVector::const_iterator i(_brushlist.begin()); i != _brushlist.end(); ++i)
{
for (BrushPtrVector::iterator j(buffer[swap].begin());
j != buffer[swap].end(); ++j)
{
if (Brush_subtract(*j, (*i)->getBrush(), buffer[1 - swap]))
{
// greebo: Delete not necessary, nodes get deleted automatically by clear() below
// delete (*j);
}
else
{
buffer[1 - swap].push_back(*j);
}
}
buffer[swap].clear();
swap = 1 - swap;
}
BrushPtrVector& out = buffer[swap];
if (out.size() == 1 && out.back() == original)
{
// greebo: shared_ptr is taking care of this
//delete original;
}
else
{
_before++;
for (BrushPtrVector::const_iterator i = out.begin(); i != out.end(); ++i)
{
_after++;
scene::INodePtr newBrush = GlobalBrushCreator().createBrush();
parent->addChildNode(newBrush);
// Move the new Brush to the same layers as the source node
newBrush->assignToLayers(node->getLayers());
(*i)->getBrush().removeEmptyFaces();
ASSERT_MESSAGE(!(*i)->getBrush().empty(), "brush left with no faces after subtract");
Node_getBrush(newBrush)->copy((*i)->getBrush());
}
_deleteList.push_back(node);
}
}
}
