const Model::EntityList ReparentBrushesCommand::emptyParents() const {
     Model::EntitySet result;
     Model::BrushParentMap::const_iterator it, end;
     for (it = m_oldParents.begin(), end = m_oldParents.end(); it != end; ++it) {
         Model::Entity& entity = *it->second;
         if (!entity.worldspawn() && entity.brushes().empty())
             result.insert(&entity);
     }
     return Utility::makeList(result);
 }
示例#2
0
        // find links in a "context"
        void EntityLinkDecorator::gatherLinks(Vec4f::List& vListLocal, Vec4f::List& vListContext, RenderContext& context, Model::Entity& curEnt, Model::EntitySet& visitedEntities) {
            Model::EntitySet::iterator vIt = visitedEntities.lower_bound(&curEnt);

            if (*vIt == &curEnt)
                return;

            visitedEntities.insert(vIt, &curEnt);

            if (!context.filter().entityVisible(curEnt))
                return;

            Model::EntityList::const_iterator it, end;
            const Model::EntityList& targetList = curEnt.linkTargets();

            for (it = targetList.begin(), end = targetList.end(); it != end; ++it) {
                Model::Entity& targetEnt = **it;

                if (!context.filter().entityVisible(targetEnt))
                    continue;

                if (curEnt.selected() || targetEnt.selected())
                    addArrowVerts(vListLocal, curEnt.center(), targetEnt.center());
                else
                    addArrowVerts(vListContext, curEnt.center(), targetEnt.center());

                gatherLinks(vListLocal, vListContext, context, targetEnt, visitedEntities);
            }

            const Model::EntityList& sourceList = curEnt.linkSources();

            for (it = sourceList.begin(), end = sourceList.end(); it != end; ++it) {
                Model::Entity& sourceEnt = **it;

                if (!context.filter().entityVisible(sourceEnt))
                    continue;

                gatherLinks(vListLocal, vListContext, context, sourceEnt, visitedEntities);
            }
        }
示例#3
0
        void NavBar::updateBreadcrump() {
            m_navPanel->DestroyChildren();
            wxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
            
            if (m_documentViewHolder.valid()) {
                Controller::InputController& inputController = m_documentViewHolder.view().inputController();
                Model::EditStateManager& editStateManager = m_documentViewHolder.document().editStateManager();
                Model::EntitySet entities = Utility::makeSet(editStateManager.selectedEntities());
                const Model::BrushList& brushes = editStateManager.selectedBrushes();
                const Model::FaceList& faces = editStateManager.selectedFaces();
                size_t totalEntityBrushCount = 0;
                
                Model::BrushList::const_iterator brushIt, brushEnd;
                for (brushIt = brushes.begin(), brushEnd = brushes.end(); brushIt != brushEnd; ++brushIt) {
                    const Model::Brush& brush = **brushIt;
                    Model::Entity* entity = brush.entity();
                    entities.insert(entity);
                }
                
                Model::EntitySet::const_iterator entityIt, entityEnd;
                for (entityIt = entities.begin(), entityEnd = entities.end(); entityIt != entityEnd; ++entityIt) {
                    const Model::Entity& entity = **entityIt;
                    totalEntityBrushCount += entity.brushes().size();
                }
                
                if (entities.empty() && brushes.empty()) {
                    if (faces.empty()) {
                        sizer->Add(makeBreadcrump(wxT("no selection"), false), 0, wxALIGN_CENTRE_VERTICAL);
                    } else {
                        Model::FaceList::const_iterator faceIt = faces.begin();
                        Model::FaceList::const_iterator faceEnd = faces.end();
                        
                        const Model::Face* face = *faceIt++;
                        const String& firstTextureName = face->textureName();
                        bool sameTexturename = true;
                        while (faceIt != faceEnd && sameTexturename) {
                            face = *faceIt++;
                            const String& textureName = face->textureName();
                            sameTexturename = (textureName == firstTextureName);
                        }
                        
                        wxString faceString;
                        faceString << faces.size() << " " << (faces.size() == 1 ? "face" : "faces");
                        if (sameTexturename)
                            faceString << " (" << (firstTextureName.empty() ? "no texture set" : firstTextureName) << ")";
                        else
                            faceString << " (multiple textures)";
                        sizer->Add(makeBreadcrump(faceString, false), 0, wxALIGN_CENTRE_VERTICAL);
                    }
                } else {
                    if (entities.size() == 1 && (*entities.begin())->worldspawn()) {
                        const Model::Entity& entity = **entities.begin();
                        const String classname = entity.classname() != NULL ? *entity.classname() : Model::Entity::NoClassnameValue;
                        sizer->Add(makeBreadcrump(classname, false), 0, wxALIGN_CENTRE_VERTICAL);
                    } else {
                        entityIt = entities.begin();
                        entityEnd = entities.end();
                        
                        const Model::Entity* entity = *entityIt++;
                        const String& firstClassname = entity->safeClassname();
                        bool sameClassname = true;
                        while (entityIt != entityEnd && sameClassname) {
                            entity = *entityIt++;
                            const String& classname = entity->safeClassname();
                            sameClassname = (classname == firstClassname);
                        }
                        
                        wxString entityString;
                        entityString << entities.size() << " ";
                        if (sameClassname)
                            entityString << firstClassname << " ";
                        entityString << (entities.size() == 1 ? "entity" : "entities");
                        sizer->Add(makeBreadcrump(entityString, false), 0, wxALIGN_CENTRE_VERTICAL);
                    }
                    if (!brushes.empty()) {
                        sizer->AddSpacer(2);
                        sizer->Add(makeBreadcrump(L"\u00BB", false), 0, wxALIGN_CENTRE_VERTICAL);
                        sizer->AddSpacer(2);
                        
                        wxString brushString;
                        brushString << brushes.size() << "/" << totalEntityBrushCount << (totalEntityBrushCount == 1 ? " brush" : " brushes");
                        sizer->Add(makeBreadcrump(brushString, false), 0, wxALIGN_CENTRE_VERTICAL);
                    }
                    if (inputController.clipToolActive()) {
                        sizer->AddSpacer(2);
                        sizer->Add(makeBreadcrump(L"\u00BB", false), 0, wxALIGN_CENTRE_VERTICAL);
                        sizer->AddSpacer(2);

                        wxString clipString = "clip tool (";
                        clipString << inputController.clipTool().numPoints() << "/3 points)";
                        sizer->Add(makeBreadcrump(clipString, false), 0, wxALIGN_CENTRE_VERTICAL);
                    } else if (inputController.moveVerticesToolActive()) {
                        sizer->AddSpacer(2);
                        sizer->Add(makeBreadcrump(L"\u00BB", false), 0, wxALIGN_CENTRE_VERTICAL);
                        sizer->AddSpacer(2);

                        Controller::MoveVerticesTool& tool = inputController.moveVerticesTool();
                        wxString vertexString = "vertex tool (";
                        if (tool.selectedVertexCount() > 0) {
                            vertexString << tool.selectedVertexCount() << "/" << tool.totalVertexCount() << " vertices";
                        } else if (tool.selectedEdgeCount() > 0) {
                            vertexString << tool.selectedEdgeCount() << "/" << tool.totalEdgeCount() << " edges";
                        } else if (tool.selectedFaceCount() > 0) {
                            vertexString << tool.selectedFaceCount() << "/" << tool.totalFaceCount() << " faces";
                        } else {
                            vertexString << "no selection";
                        }
                        vertexString << ")";
                        sizer->Add(makeBreadcrump(vertexString, false), 0, wxALIGN_CENTRE_VERTICAL);
                    }
                }
            }
            
            m_navPanel->SetSizer(sizer);
            Layout();
        }