kindred/create
1
1
Fork 0
Code Issues 31 Pull Requests Actions 6 Packages Projects 9 Releases 2 Wiki Activity

Merge pull request #23062 from kadet1090/pd-boolean-preview

Browse Source 
PartDesign: Implement preview for Booleans
This commit is contained in:
Chris Hennes
2025-08-31 15:36:38 -05:00
committed by GitHub
parent da32a949f2 332ba3854a
commit 143738e8d5
11 changed files with 246 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/Mod/Part/Gui/ViewProviderPreviewExtension.cpp
View File

@@ -29,6 +29,7 @@
# include <Inventor/nodes/SoMaterial.h>
# include <Inventor/nodes/SoPickStyle.h>
# include <Inventor/nodes/SoPolygonOffset.h>
# include <Inventor/nodes/SoTransform.h>
#endif
#include "ViewProviderPreviewExtension.h"
@@ -53,6 +54,9 @@ SoPreviewShape::SoPreviewShape()
SO_NODE_ADD_FIELD(color, (defaultColor));
SO_NODE_ADD_FIELD(transparency, (defaultTransparency));
SO_NODE_ADD_FIELD(lineWidth, (defaultLineWidth));
SO_NODE_ADD_FIELD(transform, (SbMatrix::identity()));
pcTransform = new SoTransform;
auto pickStyle = new SoPickStyle;
pickStyle->style = SoPickStyle::UNPICKABLE;
@@ -103,6 +107,7 @@ SoPreviewShape::SoPreviewShape()
annotation->addChild(polygonOffset);
annotation->addChild(faceset);
SoSeparator::addChild(pcTransform);
SoSeparator::addChild(pickStyle);
SoSeparator::addChild(solidLineStyle);
SoSeparator::addChild(material);
@@ -119,6 +124,14 @@ void SoPreviewShape::initClass()
SO_NODE_INIT_CLASS(SoPreviewShape, SoSeparator, "Separator");
}
void SoPreviewShape::notify(SoNotList* nl)
{
SoField* field = nl->getLastField();
if (field == &transform) {
pcTransform->setMatrix(transform.getValue());
}
}
EXTENSION_PROPERTY_SOURCE(PartGui::ViewProviderPreviewExtension, Gui::ViewProviderExtension)
ViewProviderPreviewExtension::ViewProviderPreviewExtension()
@@ -224,6 +237,7 @@ void ViewProviderPreviewExtension::updatePreviewShape(Part::TopoShape shape,
try {
updatePreviewShape(preview, shape);
preview->transform.setValue(Base::convertTo<SbMatrix>(shape.getTransform()));
} catch (Standard_Failure& e) {
Base::Console().userTranslatedNotification(
tr("Failure while rendering preview: %1. That usually indicates an error with model.")

7
src/Mod/Part/Gui/ViewProviderPreviewExtension.h
View File

@@ -43,6 +43,7 @@
#include <Gui/ViewProviderExtension.h>
#include <Gui/ViewProviderExtensionPython.h>
#include <Inventor/fields/SoSFMatrix.h>
#include <Mod/Part/App/TopoShape.h>
namespace PartGui {
@@ -59,9 +60,15 @@ public:
SoPreviewShape();
static void initClass();
void notify(SoNotList* nl) override;
SoSFColor color;
SoSFFloat transparency;
SoSFFloat lineWidth;
SoSFMatrix transform;
private:
SoTransform* pcTransform;
};
class PartGuiExport ViewProviderPreviewExtension : public Gui::ViewProviderExtension {

40
src/Mod/PartDesign/App/FeatureBoolean.cpp
View File

@@ -164,21 +164,55 @@ App::DocumentObjectExecReturn *Boolean::execute()
}
this->Shape.setValue(getSolid(result));
return App::DocumentObject::StdReturn;
return StdReturn;
}
void Boolean::updatePreviewShape()
{
if (strcmp(Type.getValueAsString(), "Cut") == 0) {
TopoShape base = getBaseTopoShape(true).moved(getLocation().Inverted());
TopoShape result = Shape.getShape();
PreviewShape.setValue(base.makeElementCut(result.getShape()));
return;
}
if (strcmp(Type.getValueAsString(), "Fuse") == 0) {
std::vector<TopoShape> shapes;
for (auto& obj : Group.getValues()) {
shapes.push_back(getTopoShape(obj, Part::ShapeOption::ResolveLink | Part::ShapeOption::Transform));
}
TopoShape result;
result.makeCompound(shapes);
PreviewShape.setValue(result.getShape());
return;
}
PreviewShape.setValue(Shape.getShape());
}
void Boolean::onChanged(const App::Property* prop) {
if(strcmp(prop->getName(), "Group") == 0)
if (strcmp(prop->getName(), "Group") == 0) {
touch();
}
PartDesign::Feature::onChanged(prop);
if (strcmp(prop->getName(), "Shape") == 0) {
updatePreviewShape();
}
Feature::onChanged(prop);
}
void Boolean::handleChangedPropertyName(Base::XMLReader &reader, const char * TypeName, const char *PropName)
{
// The App::PropertyLinkList property was Bodies in the past
Base::Type type = Base::Type::fromName(TypeName);
if (Group.getClassTypeId() == type && strcmp(PropName, "Bodies") == 0) {
Group.Restore(reader);
}

1
src/Mod/PartDesign/App/FeatureBoolean.h
View File

@@ -52,6 +52,7 @@ public:
//@{
/// Recalculate the feature
App::DocumentObjectExecReturn *execute() override;
void updatePreviewShape() override;
short mustExecute() const override;
/// returns the type name of the view provider
const char* getViewProviderName() const override {

7
src/Mod/PartDesign/Gui/StyleParameters.h
View File

@@ -29,13 +29,14 @@
namespace PartDesignGui::StyleParameters {
DEFINE_STYLE_PARAMETER(PreviewAdditiveColor, Base::Color(0.0F, 1.0F, 0.6F));
DEFINE_STYLE_PARAMETER(PreviewSubtractiveColor, Base::Color(1.0F, 0.0F, 0.0F));
DEFINE_STYLE_PARAMETER(PreviewCommonColor, Base::Color(1.0F, 1.0F, 0.0F));
DEFINE_STYLE_PARAMETER(PreviewDressUpColor, Base::Color(1.0F, 0.0F, 1.0F));
DEFINE_STYLE_PARAMETER(PreviewErrorColor, Base::Color(1.0F, 0.0F, 0.0F));
DEFINE_STYLE_PARAMETER(PreviewErrorTransparency, Gui::StyleParameters::Numeric(0.95));
DEFINE_STYLE_PARAMETER(PreviewErrorOpacity, Gui::StyleParameters::Numeric(0.05));
DEFINE_STYLE_PARAMETER(PreviewToolTransparency, Gui::StyleParameters::Numeric(0.95));
DEFINE_STYLE_PARAMETER(PreviewShapeTransparency, Gui::StyleParameters::Numeric(0.8));
DEFINE_STYLE_PARAMETER(PreviewToolOpacity, Gui::StyleParameters::Numeric(0.05));
DEFINE_STYLE_PARAMETER(PreviewShapeOpacity, Gui::StyleParameters::Numeric(0.2));
DEFINE_STYLE_PARAMETER(PreviewLineWidth, Gui::StyleParameters::Numeric(2));
}

3
src/Mod/PartDesign/Gui/TaskBooleanParameters.cpp
View File

@@ -352,13 +352,14 @@ void TaskBooleanParameters::exitSelectionMode()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskDlgBooleanParameters::TaskDlgBooleanParameters(ViewProviderBoolean* BooleanView)
: TaskDialog()
: TaskDlgFeatureParameters(BooleanView)
, BooleanView(BooleanView)
{
assert(BooleanView);
parameter = new TaskBooleanParameters(BooleanView);
Content.push_back(parameter);
Content.push_back(preview);
}
TaskDlgBooleanParameters::~TaskDlgBooleanParameters() = default;

5
src/Mod/PartDesign/Gui/TaskBooleanParameters.h
View File

@@ -24,6 +24,9 @@
#ifndef GUI_TASKVIEW_TaskBooleanParameters_H
#define GUI_TASKVIEW_TaskBooleanParameters_H
#include "TaskFeatureParameters.h"
#include <Gui/TaskView/TaskDialog.h>
#include <Gui/TaskView/TaskView.h>
@@ -78,7 +81,7 @@ private:
};
/// simulation dialog for the TaskView
class TaskDlgBooleanParameters : public Gui::TaskView::TaskDialog
class TaskDlgBooleanParameters : public TaskDlgFeatureParameters
{
Q_OBJECT

7
src/Mod/PartDesign/Gui/ViewProvider.cpp
View File

@@ -221,10 +221,13 @@ void ViewProvider::attachPreview()
auto* styleParameterManager = Base::provideService<Gui::StyleParameters::ParameterManager>();
pcPreviewShape->lineWidth = styleParameterManager->resolve(StyleParameters::PreviewLineWidth).value;
const double opacity = styleParameterManager->resolve(StyleParameters::PreviewToolOpacity).value;
const double lineWidth = styleParameterManager->resolve(StyleParameters::PreviewLineWidth).value;
pcPreviewShape->lineWidth = static_cast<float>(lineWidth);
pcToolPreview = new PartGui::SoPreviewShape;
pcToolPreview->transparency = styleParameterManager->resolve(StyleParameters::PreviewToolTransparency).value;
pcToolPreview->transparency = 1.0F - static_cast<float>(opacity);
pcToolPreview->color.connectFrom(&pcPreviewShape->color);
pcPreviewRoot->addChild(pcToolPreview);

218
src/Mod/PartDesign/Gui/ViewProviderBoolean.cpp
View File

@@ -1,6 +1,7 @@
/***************************************************************************
* Copyright (c) 2013 Jan Rheinländer *
* <jrheinlaender@users.sourceforge.net> *
* Copyright (c) 2025 Kacper Donat <kacper@kadet.net> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
@@ -26,30 +27,39 @@
#ifndef _PreComp_
# include <QMenu>
# include <QMessageBox>
# include <Inventor/nodes/SoTransform.h>
#endif
#include "ViewProviderBoolean.h"
#include "StyleParameters.h"
#include "TaskBooleanParameters.h"
#include <Base/ServiceProvider.h>
#include <Mod/PartDesign/App/FeatureBoolean.h>
#include <Gui/Application.h>
#include <Gui/Control.h>
#include <Gui/Command.h>
#include <Gui/Document.h>
#include <Gui/MainWindow.h>
#include <Gui/Utilities.h>
#include <Mod/PartDesign/App/Body.h>
#include <Mod/Sketcher/Gui/TaskDlgEditSketch.h>
using namespace PartDesignGui;
PROPERTY_SOURCE_WITH_EXTENSIONS(PartDesignGui::ViewProviderBoolean,PartDesignGui::ViewProvider)
const char* PartDesignGui::ViewProviderBoolean::DisplayEnum[] = {"Result","Tools",nullptr};
const char* PartDesignGui::ViewProviderBoolean::DisplayEnum[] = {"Result", "Tools", nullptr};
ViewProviderBoolean::ViewProviderBoolean()
: pcToolsPreview(new SoGroup)
, pcBasePreviewToggle(new SoToggleSwitch)
{
sPixmap = "PartDesign_Boolean.svg";
Gui::ViewProviderGeoFeatureGroupExtension::initExtension(this);
ViewProviderGeoFeatureGroupExtension::initExtension(this);
ADD_PROPERTY(Display,((long)0));
Display.setEnums(DisplayEnum);
@@ -57,62 +67,19 @@ ViewProviderBoolean::ViewProviderBoolean()
ViewProviderBoolean::~ViewProviderBoolean() = default;
void ViewProviderBoolean::setupContextMenu(QMenu* menu, QObject* receiver, const char* member)
{
addDefaultAction(menu, QObject::tr("Edit Boolean"));
PartDesignGui::ViewProvider::setupContextMenu(menu, receiver, member);
}
bool ViewProviderBoolean::setEdit(int ModNum)
{
if (ModNum == ViewProvider::Default ) {
// When double-clicking on the item for this fillet the
// object unsets and sets its edit mode without closing
// the task panel
Gui::TaskView::TaskDialog *dlg = Gui::Control().activeDialog();
TaskDlgBooleanParameters *booleanDlg = qobject_cast<TaskDlgBooleanParameters *>(dlg);
if (booleanDlg && booleanDlg->getBooleanView() != this)
booleanDlg = nullptr; // another pad left open its task panel
if (dlg && !booleanDlg) {
QMessageBox msgBox(Gui::getMainWindow());
msgBox.setText(QObject::tr("A dialog is already open in the task panel"));
msgBox.setInformativeText(QObject::tr("Close this dialog?"));
msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
msgBox.setDefaultButton(QMessageBox::Yes);
int ret = msgBox.exec();
if (ret == QMessageBox::Yes)
Gui::Control().closeDialog();
else
return false;
}
// clear the selection (convenience)
Gui::Selection().clearSelection();
// always change to PartDesign WB, remember where we come from
oldWb = Gui::Command::assureWorkbench("PartDesignWorkbench");
// start the edit dialog
if (booleanDlg)
Gui::Control().showDialog(booleanDlg);
else
Gui::Control().showDialog(new TaskDlgBooleanParameters(this));
return true;
}
else {
return PartGui::ViewProviderPart::setEdit(ModNum); // clazy:exclude=skipped-base-method
}
ViewProvider::setupContextMenu(menu, receiver, member);
}
bool ViewProviderBoolean::onDelete(const std::vector<std::string> &s)
{
PartDesign::Boolean* pcBoolean = getObject<PartDesign::Boolean>();
auto* feature = getObject<PartDesign::Boolean>();
// if abort command deleted the object the bodies are visible again
std::vector<App::DocumentObject*> bodies = pcBoolean->Group.getValues();
for (auto body : bodies) {
for (auto body : feature->Group.getValues()) {
if (auto vp = Gui::Application::Instance->getViewProvider(body)) {
vp->show();
}
@@ -121,11 +88,6 @@ bool ViewProviderBoolean::onDelete(const std::vector<std::string> &s)
return ViewProvider::onDelete(s);
}
void ViewProviderBoolean::attach(App::DocumentObject* obj)
{
PartGui::ViewProviderPartExt::attach(obj);
}
const char* ViewProviderBoolean::getDefaultDisplayMode() const
{
return "Flat Lines";
@@ -133,18 +95,142 @@ const char* ViewProviderBoolean::getDefaultDisplayMode() const
void ViewProviderBoolean::onChanged(const App::Property* prop) {
PartDesignGui::ViewProvider::onChanged(prop);
ViewProvider::onChanged(prop);
if(prop == &Display) {
if (prop == &Display) {
const auto getDisplayMode = [this]() {
if (Display.getValue() != 0) {
return "Group";
}
if(Display.getValue() == 0) {
auto vp = getBodyViewProvider();
if(vp)
setDisplayMode(vp->DisplayMode.getValueAsString());
else
setDisplayMode("Flat Lines");
} else {
setDisplayMode("Group");
}
if (auto bodyViewProvider = getBodyViewProvider()) {
return bodyViewProvider->DisplayMode.getValueAsString();
}
return getDefaultDisplayMode();
};
setDisplayMode(getDisplayMode());
}
if (prop == &Visibility) {
updateBasePreviewVisibility();
}
}
void ViewProviderBoolean::updateData(const App::Property* prop)
{
auto feature = getObject<PartDesign::Boolean>();
if (prop == &feature->Type) {
const auto* styleParameterManager = Base::provideService<Gui::StyleParameters::ParameterManager>();
const auto type = feature->Type.getValueAsString();
const std::map<std::string_view, Gui::StyleParameters::ParameterDefinition<Base::Color>> lookup {
{"Cut", StyleParameters::PreviewSubtractiveColor},
{"Common", StyleParameters::PreviewCommonColor},
{"Fuse", StyleParameters::PreviewAdditiveColor},
};
if (lookup.contains(type)) {
PreviewColor.setValue(styleParameterManager->resolve(lookup.at(type)));
}
updateBasePreviewVisibility();
}
ViewProvider::updateData(prop);
}
void ViewProviderBoolean::attachPreview()
{
ViewProvider::attachPreview();
pcPreviewRoot->addChild(this->pcToolsPreview);
pcPreviewRoot->addChild(this->pcBasePreviewToggle);
}
void ViewProviderBoolean::updatePreview()
{
const auto* styleParameterManager = Base::provideService<Gui::StyleParameters::ParameterManager>();
const double toolOpacity = styleParameterManager->resolve(StyleParameters::PreviewToolOpacity).value;
const double toolTransparency = 1.0 - toolOpacity;
auto boolean = getObject<PartDesign::Boolean>();
if (!boolean) {
return;
}
const auto addToolPreview = [this, toolTransparency](App::DocumentObject* tool) {
const auto feature = freecad_cast<Part::Feature*>(tool);
if (!feature) {
return;
}
Part::TopoShape toolShape = feature->Shape.getShape();
auto pcToolPreview = new PartGui::SoPreviewShape;
updatePreviewShape(toolShape, pcToolPreview);
pcToolPreview->transparency.setValue(static_cast<float>(toolTransparency));
pcToolPreview->color.connectFrom(&pcPreviewShape->color);
pcToolPreview->lineWidth.connectFrom(&pcPreviewShape->lineWidth);
pcToolsPreview->addChild(pcToolPreview);
};
const auto addBaseShapePreview = [this, toolTransparency, boolean]() {
auto baseFeature = dynamic_cast<PartDesign::Feature*>(boolean->BaseFeature.getValue());
if (!baseFeature) {
return;
}
auto baseFeatureViewProvider = freecad_cast<ViewProvider*>(Gui::Application::Instance->getViewProvider(baseFeature));
if (!baseFeatureViewProvider) {
return;
}
auto pcBaseShapePreview = new PartGui::SoPreviewShape;
updatePreviewShape(baseFeature->Shape.getShape(), pcBaseShapePreview);
pcBaseShapePreview->transparency.setValue(static_cast<float>(toolTransparency));
pcBaseShapePreview->color.setValue(baseFeatureViewProvider->ShapeAppearance.getDiffuseColor().asValue<SbColor>());
pcBaseShapePreview->lineWidth.connectFrom(&pcPreviewShape->lineWidth);
pcBasePreviewToggle->addChild(pcBaseShapePreview);
};
try {
const auto& tools = boolean->Group.getValues();
if (tools.empty()) {
return;
}
Gui::coinRemoveAllChildren(pcToolsPreview);
Gui::coinRemoveAllChildren(pcBasePreviewToggle);
addBaseShapePreview();
std::ranges::for_each(tools, addToolPreview);
} catch (const Base::Exception& e) {
e.reportException();
}
ViewProvider::updatePreview();
}
TaskDlgFeatureParameters* ViewProviderBoolean::getEditDialog()
{
return new TaskDlgBooleanParameters(this);
}
void ViewProviderBoolean::updateBasePreviewVisibility()
{
auto feature = getObject<PartDesign::Boolean>();
// enable base preview for Common operation only and when the final result is shown
pcBasePreviewToggle->on = strcmp(feature->Type.getValueAsString(), "Common") == 0 && Visibility.getValue();
}

15
src/Mod/PartDesign/Gui/ViewProviderBoolean.h
View File

@@ -1,6 +1,7 @@
/***************************************************************************
* Copyright (c) 2013 Jan Rheinländer *
* <jrheinlaender@users.sourceforge.net> *
* Copyright (c) 2025 Kacper Donat <kacper@kadet.net> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
@@ -27,6 +28,7 @@
#include "ViewProvider.h"
#include <Gui/ViewProviderGeoFeatureGroupExtension.h>
#include <Gui/Inventor/SoToggleSwitch.h>
namespace PartDesignGui {
@@ -48,15 +50,24 @@ public:
void setupContextMenu(QMenu*, QObject*, const char*) override;
bool onDelete(const std::vector<std::string> &) override;
void attach(App::DocumentObject*) override;
const char* getDefaultDisplayMode() const override;
void onChanged(const App::Property* prop) override;
protected:
bool setEdit(int ModNum) override;
void updateData(const App::Property* prop) override;
void attachPreview() override;
void updatePreview() override;
TaskDlgFeatureParameters* getEditDialog() override;
static const char* DisplayEnum[];
private:
void updateBasePreviewVisibility();
Gui::CoinPtr<SoGroup> pcToolsPreview;
Gui::CoinPtr<SoToggleSwitch> pcBasePreviewToggle;
};
} // namespace PartDesignGui

12
src/Mod/PartDesign/Gui/ViewProviderDressUp.cpp
View File

@@ -140,12 +140,14 @@ void ViewProviderDressUp::setErrorState(bool error)
{
auto* styleParameterManager = Base::provideService<Gui::StyleParameters::ParameterManager>();
pcPreviewShape->transparency = styleParameterManager
->resolve(error ? StyleParameters::PreviewErrorTransparency
: StyleParameters::PreviewShapeTransparency)
.value;
const float opacity =
static_cast<float>(styleParameterManager
->resolve(error ? StyleParameters::PreviewErrorOpacity
: StyleParameters::PreviewShapeOpacity)
.value);
pcPreviewShape->transparency = 1.0F - opacity;
pcPreviewShape->color = error
? styleParameterManager->resolve(StyleParameters::PreviewErrorColor).asValue<SbColor>()
: PreviewColor.getValue().asValue<SbColor>();
}