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); } } }