kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
f323323e8b5ef92f00ad3542947dbc5460b5be7e
create/src/Gui/SceneInspector.cpp
Markus Reitböck 6ef07bb358 Gui: use CMake to generate precompiled headers on all platforms 
"Professional CMake" book suggest the following:

"Targets should build successfully with or without compiler support for precompiled headers. It
should be considered an optimization, not a requirement. In particular, do not explicitly include a
precompile header (e.g. stdafx.h) in the source code, let CMake force-include an automatically
generated precompile header on the compiler command line instead. This is more portable across
the major compilers and is likely to be easier to maintain. It will also avoid warnings being
generated from certain code checking tools like iwyu (include what you use)."

Therefore, removed the "#include <PreCompiled.h>" from sources, also
there is no need for the "#ifdef _PreComp_" anymore
2025-09-14 09:47:03 +02:00

410 lines
14 KiB
C++
Raw Blame History

/***************************************************************************
* Copyright (c) 2008 Werner Mayer <wmayer[at]users.sourceforge.net> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Library General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Library General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this library; see the file COPYING.LIB. If not, *
* write to the Free Software Foundation, Inc., 59 Temple Place, *
* Suite 330, Boston, MA 02111-1307, USA *
* *
***************************************************************************/
# include <Inventor/nodes/SoSeparator.h>
# include <Inventor/nodes/SoDrawStyle.h>
# include <Inventor/nodes/SoPickStyle.h>
# include <Inventor/nodes/SoCoordinate3.h>
# include <QHeaderView>
# include <QTextStream>
#include <Inventor/actions/SoGetBoundingBoxAction.h>
#include "SceneInspector.h"
#include "ui_SceneInspector.h"
#include "Application.h"
#include "Document.h"
#include "View3DInventor.h"
#include "View3DInventorViewer.h"
#include "ViewProviderDocumentObject.h"
#include "MainWindow.h"
#include <limits>
using namespace Gui::Dialog;
/* TRANSLATOR Gui::Dialog::SceneModel */
SceneModel::SceneModel(QObject* parent)
: QStandardItemModel(parent)
{
}
enum class Column: std::int8_t {
INVENTOR_TREE = 0,
NAME = 1,
MEMORY_ADDRESS = 2,
DATA = 3,
RENDER_CACHING = 4,
BOUNDING_BOX_CACHING = 5,
BOUNDING_BOX = 6,
COUNT = 7,
};
SceneModel::~SceneModel() = default;
int SceneModel::columnCount (const QModelIndex & parent) const
{
Q_UNUSED(parent);
return static_cast<int>(Column::COUNT);
}
Qt::ItemFlags SceneModel::flags (const QModelIndex & index) const
{
return QAbstractItemModel::flags(index);
}
QVariant SceneModel::headerData (int section, Qt::Orientation orientation, int role) const
{
if (orientation == Qt::Horizontal) {
if (role != Qt::DisplayRole)
return {};
switch ((Column)section) {
case Column::INVENTOR_TREE:
return tr("Inventor Tree");
case Column::NAME:
return tr("Name");
case Column::MEMORY_ADDRESS:
return tr("Address");
case Column::DATA:
return tr("Data");
case Column::RENDER_CACHING:
return tr("Render Cache");
case Column::BOUNDING_BOX_CACHING:
return tr("Bounds Cache");
case Column::BOUNDING_BOX:
return tr("Bounds");
default:
assert(0 && "Not handled yet");
}
}
return {};
}
bool SceneModel::setHeaderData (int, Qt::Orientation, const QVariant &, int)
{
return false;
}
void SceneModel::setNode(SoNode* node)
{
this->clear();
this->setHeaderData(0, Qt::Horizontal, tr("Nodes"), Qt::DisplayRole);
this->insertColumns(0, static_cast<int>(Column::COUNT));
this->insertRows(0,1);
setNode(this->index(0, 0), node);
}
static std::string_view formatSoSwitchValue(int32_t value)
{
switch (value)
{
case SO_SWITCH_NONE:
return {"None"};
case SO_SWITCH_INHERIT:
return {"Inherit"};
case SO_SWITCH_ALL:
return {"All"};
default:
return {"Child"};
}
}
static std::string_view formatSoSeparatorCacheEnabled(int32_t value)
{
switch (value)
{
case SoSeparator::OFF:
return {"Off"};
case SoSeparator::ON:
return {"On"};
case SoSeparator::AUTO:
return {"Auto"};
default:
throw Base::ValueError();
}
}
static std::string_view formatSoDrawStyleElement(int32_t value)
{
switch (value)
{
case SoDrawStyleElement::FILLED:
return {"Filled"};
case SoDrawStyleElement::LINES:
return {"Lines"};
case SoDrawStyleElement::POINTS:
return {"Points"};
case SoDrawStyleElement::INVISIBLE:
return {"Invisible"};
default:
throw Base::ValueError();
}
}
static std::string_view formatSoPickStyleElement(int32_t value)
{
switch (value)
{
case SoPickStyleElement::SHAPE:
return {"Shape"};
case SoPickStyleElement::BOUNDING_BOX:
return {"BoundingBox"};
case SoPickStyleElement::UNPICKABLE:
return {"Unpickable"};
case SoPickStyleElement::SHAPE_ON_TOP:
return {"ShapeOnTop"};
case SoPickStyleElement::BOUNDING_BOX_ON_TOP:
return {"BoundingBoxOnTop"};
case SoPickStyleElement::SHAPE_FRONTFACES:
return {"ShapeFrontFaces"};
default:
throw Base::ValueError();
}
}
static inline bool isAtFloatValueLimit(float v)
{
return v == std::numeric_limits<float>::lowest() || v == std::numeric_limits<float>::max();
}
static bool isInfinite(const SbVec3f& vec)
{
float x, y, z; //NOLINT
vec.getValue(x, y, z);
return isAtFloatValueLimit(x) && isAtFloatValueLimit(y) && isAtFloatValueLimit(z);
}
static std::string formatSbXfBox3f(const SbXfBox3f& box)
{
SbVec3f minpoint;
SbVec3f maxpoint;
box.getBounds(minpoint, maxpoint);
if (isInfinite(minpoint) && isInfinite(maxpoint)) {
return {"Infinite"};
}
float minx, miny, minz; //NOLINT
minpoint.getValue(minx, miny, minz);
float maxx, maxy, maxz; //NOLINT
maxpoint.getValue(maxx, maxy, maxz);
return fmt::format("Min: ({:.3},{:.3},{:.3}), Max: ({:.3},{:.3},{:.3})", minx, miny, minz, maxx, maxy, maxz);
}
void SceneModel::setNode(QModelIndex index, SoNode* node)
{
this->setData(index.siblingAtColumn(static_cast<int>(Column::INVENTOR_TREE)),
QVariant(QString::fromLatin1(QByteArray(node->getTypeId().getName()))));
QHash<SoNode*, QString>::iterator it = nodeNames.find(node);
const QString name {
(it != nodeNames.end()) ? it.value()
: QString::fromLatin1(QByteArray(node->getName()))
};
this->setData(index.siblingAtColumn(static_cast<int>(Column::NAME)), QVariant(name));
this->setData(index.siblingAtColumn(static_cast<int>(Column::MEMORY_ADDRESS)),
QVariant(QString::fromStdString(fmt::format("{}", (void*)node))));
auto view = qobject_cast<View3DInventor*>(getMainWindow()->activeWindow());
auto vp = view->getViewer()->getSoRenderManager()->getViewportRegion();
QString data;
QTextStream stream(&data);
if(static_cast<bool>(node->isOfType(SoSwitch::getClassTypeId()))) {
auto pcSwitch = static_cast<SoSwitch*>(node);
auto value = pcSwitch->whichChild.getValue();
stream << fmt::format("Which: {} ({})", formatSoSwitchValue(value), value).c_str();
} else if (static_cast<bool>(node->isOfType(SoSeparator::getClassTypeId()))) {
auto pcSeparator = static_cast<SoSeparator*>(node);
auto renderCaching = pcSeparator->renderCaching.getValue();
this->setData(index.siblingAtColumn(static_cast<int>(Column::RENDER_CACHING)),
QVariant(QString::fromStdString(std::string{formatSoSeparatorCacheEnabled(renderCaching)})));
auto boundingBoxCaching = pcSeparator->boundingBoxCaching.getValue();
this->setData(index.siblingAtColumn(static_cast<int>(Column::BOUNDING_BOX_CACHING)),
QVariant(QString::fromStdString(std::string{formatSoSeparatorCacheEnabled(boundingBoxCaching)})));
SoGetBoundingBoxAction getBBox(vp);
getBBox.apply(pcSeparator);
this->setData(index.siblingAtColumn(static_cast<int>(Column::BOUNDING_BOX)),
QVariant(QString::fromStdString(formatSbXfBox3f(getBBox.getXfBoundingBox()))));
} else if (static_cast<bool>(node->isOfType(SoDrawStyle::getClassTypeId()))) {
auto pcDrawStyle = static_cast<SoDrawStyle*>(node);
auto value = pcDrawStyle->style.getValue();
stream << fmt::format("Style: {} ({})", formatSoDrawStyleElement(value), value).c_str();
} else if (static_cast<bool>(node->isOfType(SoPickStyle::getClassTypeId()))) {
auto pcPickStyle = static_cast<SoPickStyle*>(node);
auto value = pcPickStyle->style.getValue();
stream << fmt::format("Style: {} ({})", formatSoPickStyleElement(value), value).c_str();
} else if (static_cast<bool>(node->isOfType(SoCoordinate3::getClassTypeId()))) {
auto pcCoords = static_cast<SoCoordinate3*>(node);
auto values = pcCoords->point.getValues(0);
if (values) {
float x { 0 };
float y { 0 };
float z { 0 };
values->getValue(x, y, z);
stream << fmt::format("XYZ: {}, {}, {}", x, y, z).c_str();
}
}
this->setData(index.siblingAtColumn((int)Column::DATA), QVariant(data));
if (static_cast<bool>(node->getTypeId().isDerivedFrom(SoGroup::getClassTypeId()))) {
auto group = static_cast<SoGroup*>(node);
this->insertColumns(0, static_cast<int>(Column::COUNT), index);
this->insertRows(0, group->getNumChildren(), index);
for (int i=0; i < group->getNumChildren(); i++) {
SoNode* child = group->getChild(i);
setNode(this->index(i, 0, index), child);
}
}
}
void SceneModel::setNodeNames(const QHash<SoNode*, QString>& names)
{
nodeNames = names;
}
// --------------------------------------------------------
/* TRANSLATOR Gui::Dialog::DlgInspector */
DlgInspector::DlgInspector(QWidget* parent, Qt::WindowFlags fl)
: QDialog(parent, fl), ui(new Ui_SceneInspector())
{
ui->setupUi(this);
connect(ui->refreshButton, &QPushButton::clicked,
this, &DlgInspector::onRefreshButtonClicked);
setWindowTitle(tr("Scene Inspector"));
auto model = new SceneModel(this);
ui->treeView->setModel(model);
ui->treeView->setRootIsDecorated(true);
}
/*
* Destroys the object and frees any allocated resources
*/
DlgInspector::~DlgInspector()
{
// no need to delete child widgets, Qt does it all for us
delete ui;
}
void DlgInspector::setDocument(Gui::Document* doc)
{
setNodeNames(doc);
auto view = qobject_cast<View3DInventor*>(doc->getActiveView());
if (view) {
View3DInventorViewer* viewer = view->getViewer();
setNode(viewer->getSceneGraph());
ui->treeView->expandToDepth(3);
}
}
void DlgInspector::setNode(SoNode* node)
{
auto model = static_cast<SceneModel*>(ui->treeView->model());
model->setNode(node);
QHeaderView* header = ui->treeView->header();
header->setSectionResizeMode(static_cast<int>(Column::INVENTOR_TREE), QHeaderView::Interactive);
header->resizeSection(static_cast<int>(Column::INVENTOR_TREE), 300);
header->setSectionResizeMode(static_cast<int>(Column::NAME), QHeaderView::Interactive);
header->resizeSection(static_cast<int>(Column::NAME), 200);
header->setSectionResizeMode(static_cast<int>(Column::MEMORY_ADDRESS), QHeaderView::Interactive);
header->resizeSection(static_cast<int>(Column::MEMORY_ADDRESS), 140);
header->setSectionResizeMode(static_cast<int>(Column::DATA), QHeaderView::Interactive);
header->resizeSection(static_cast<int>(Column::DATA), 200);
header->setSectionsMovable(false);
}
void DlgInspector::setNodeNames(Gui::Document* doc)
{
std::vector<Gui::ViewProvider*> vps = doc->getViewProvidersOfType
(Gui::ViewProviderDocumentObject::getClassTypeId());
QHash<SoNode*, QString> nodeNames;
for (const auto & it : vps) {
auto vp = static_cast<Gui::ViewProviderDocumentObject*>(it);
App::DocumentObject* obj = vp->getObject();
if (obj) {
QString label = QString::fromUtf8(obj->Label.getValue());
nodeNames[vp->getRoot()] = label;
}
std::vector<std::string> modes = vp->getDisplayMaskModes();
for (const auto & mode : modes) {
SoNode* node = vp->getDisplayMaskMode(mode.c_str());
if (node) {
nodeNames[node] = QString::fromStdString(mode);
}
}
}
auto model = static_cast<SceneModel*>(ui->treeView->model());
model->setNodeNames(nodeNames);
}
void DlgInspector::changeEvent(QEvent *e)
{
if (e->type() == QEvent::LanguageChange) {
ui->retranslateUi(this);
setWindowTitle(tr("Scene Inspector"));
}
QDialog::changeEvent(e);
}
void DlgInspector::onRefreshButtonClicked()
{
Gui::Document* doc = Application::Instance->activeDocument();
if (doc) {
setNodeNames(doc);
auto view = qobject_cast<View3DInventor*>(doc->getActiveView());
if (view) {
View3DInventorViewer* viewer = view->getViewer();
setNode(viewer->getSceneGraph());
ui->treeView->expandToDepth(3);
}
}
else {
auto model = static_cast<SceneModel*>(ui->treeView->model());
model->clear();
}
}
#include "moc_SceneInspector.cpp"
Reference in New Issue View Git Blame Copy Permalink