kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
a68716905911c9afc6e7e3947a0c4e4ce356cbab
create/src/Gui/Inventor/SoFCPlacementIndicatorKit.cpp
Markus Reitböck a72a0d6405 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

313 lines
11 KiB
C++
Raw Blame History

// SPDX-License-Identifier: LGPL-2.1-or-later
/****************************************************************************
* *
* Copyright (c) 2024 Kacper Donat <kacper@kadet.net> *
* *
* This file is part of FreeCAD. *
* *
* FreeCAD is free software: you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as *
* published by the Free Software Foundation, either version 2.1 of the *
* License, or (at your option) any later version. *
* *
* FreeCAD 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 *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with FreeCAD. If not, see *
* <https://www.gnu.org/licenses/>. *
* *
***************************************************************************/
#include <sstream>
#include <Inventor/nodes/SoBaseColor.h>
#include <Inventor/nodes/SoComplexity.h>
#include <Inventor/nodes/SoCone.h>
#include <Inventor/nodes/SoCylinder.h>
#include <Inventor/nodes/SoDrawStyle.h>
#include <Inventor/nodes/SoLightModel.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/nodes/SoRotation.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoSphere.h>
#include <Inventor/nodes/SoTransform.h>
#include <Inventor/nodes/SoTranslation.h>
#include <Inventor/nodes/SoFontStyle.h>
#include "SoFCPlacementIndicatorKit.h"
#include "So3DAnnotation.h"
#include "SoAxisCrossKit.h"
#include <SoTextLabel.h>
#include <Utilities.h>
#include <ViewParams.h>
#include <ViewProvider.h>
#include <Base/Color.h>
#include <Base/Placement.h>
#include <Base/Vector3D.h>
namespace Gui
{
SO_KIT_SOURCE(SoFCPlacementIndicatorKit);
SoFCPlacementIndicatorKit::SoFCPlacementIndicatorKit()
{
SO_KIT_CONSTRUCTOR(SoFCPlacementIndicatorKit);
SO_KIT_ADD_CATALOG_ENTRY(root, SoShapeScale, false, this, "", true);
SO_KIT_INIT_INSTANCE();
SO_NODE_ADD_FIELD(coloredAxis, (true));
SO_NODE_ADD_FIELD(scaleFactor, (ViewParams::instance()->getPlacementIndicatorScale()));
SO_NODE_ADD_FIELD(axisLength, (axisLengthDefault));
SO_NODE_ADD_FIELD(parts, (AxisCross));
SO_NODE_ADD_FIELD(axes, (AllAxes));
SO_NODE_DEFINE_ENUM_VALUE(Part, Axes);
SO_NODE_DEFINE_ENUM_VALUE(Part, ArrowHeads);
SO_NODE_DEFINE_ENUM_VALUE(Part, Labels);
SO_NODE_DEFINE_ENUM_VALUE(Part, AxisCross);
SO_NODE_DEFINE_ENUM_VALUE(Part, PlaneIndicator);
SO_NODE_DEFINE_ENUM_VALUE(Part, OriginIndicator);
SO_NODE_DEFINE_ENUM_VALUE(Part, AllParts);
SO_NODE_SET_SF_ENUM_TYPE(parts, Part);
SO_NODE_DEFINE_ENUM_VALUE(Axes, X);
SO_NODE_DEFINE_ENUM_VALUE(Axes, Y);
SO_NODE_DEFINE_ENUM_VALUE(Axes, Z);
SO_NODE_DEFINE_ENUM_VALUE(Axes, AllAxes);
SO_NODE_SET_SF_ENUM_TYPE(axes, Axes);
auto root = SO_GET_ANY_PART(this, "root", SoShapeScale);
root->scaleFactor.connectFrom(&scaleFactor);
recomputeGeometry();
}
void SoFCPlacementIndicatorKit::initClass()
{
SO_KIT_INIT_CLASS(SoFCPlacementIndicatorKit, SoBaseKit, "BaseKit");
}
void SoFCPlacementIndicatorKit::notify(SoNotList* l)
{
SoField* field = l->getLastField();
if (field == &parts || field == &axes || field == &axisLength) {
// certainly this is not the fastest way to recompute the geometry as it does recreate
// everything from the scratch. It is however very easy to implement and this node should
// not really change too often so the performance penalty is better than making code that
// is harder to maintain.
recomputeGeometry();
return;
}
SoBaseKit::notify(l);
}
void SoFCPlacementIndicatorKit::recomputeGeometry()
{
auto root = SO_GET_ANY_PART(this, "root", SoShapeScale);
root->setPart("shape", createGeometry());
}
SoSeparator* SoFCPlacementIndicatorKit::createOriginIndicator()
{
const uint32_t originColor = ViewParams::instance()->getOriginColor();
auto sep = new SoSeparator();
auto pcBaseColor = new SoBaseColor();
pcBaseColor->rgb.setValue(Base::Color::fromPackedRGBA<SbColor>(originColor));
auto pcSphere = new SoSphere();
// the factor aligns radius of sphere and arrow head visually, without it, it looks too small
constexpr float visualAdjustmentFactor = 1.2F;
pcSphere->radius = arrowHeadRadius * visualAdjustmentFactor;
sep->addChild(pcBaseColor);
sep->addChild(pcSphere);
return sep;
}
SoSeparator* SoFCPlacementIndicatorKit::createGeometry()
{
const uint32_t neutralColor = ViewParams::instance()->getNeutralColor();
auto sep = new SoSeparator();
auto pcBaseColor = new SoBaseColor();
pcBaseColor->rgb.setValue(Base::Color::fromPackedRGBA<SbColor>(neutralColor));
auto pcLightModel = new SoLightModel();
pcLightModel->model = SoLightModel::BASE_COLOR;
sep->addChild(pcBaseColor);
sep->addChild(pcLightModel);
if (parts.getValue() & PlaneIndicator) {
sep->addChild(createPlaneIndicator());
}
if (parts.getValue() & OriginIndicator) {
sep->addChild(createOriginIndicator());
}
if (parts.getValue() & Axes) {
sep->addChild(createAxes());
}
return sep;
}
SoSeparator* SoFCPlacementIndicatorKit::createAxes()
{
const auto cylinderOffset = axisLength.getValue() / 2.F;
const auto createAxis = [&](const char* label,
Base::Vector3d axis,
uint32_t packedColor,
const double offset) {
Base::Color axisColor(packedColor);
Base::Rotation rotation(Base::Vector3d::UnitY, axis);
auto sep = new SoSeparator;
auto pcTranslate = new SoTransform();
pcTranslate->translation.setValue(
Base::convertTo<SbVec3f>((cylinderOffset + offset) * axis));
pcTranslate->rotation.setValue(Base::convertTo<SbRotation>(rotation));
auto pcArrowShaft = new SoCylinder();
pcArrowShaft->radius = axisThickness / 2.F;
pcArrowShaft->height = axisLength;
if (coloredAxis.getValue()) {
auto pcBaseColor = new SoBaseColor();
pcBaseColor->rgb.setValue(Base::convertTo<SbColor>(axisColor));
sep->addChild(pcBaseColor);
}
sep->addChild(pcTranslate);
sep->addChild(pcArrowShaft);
if (parts.getValue() & ArrowHeads) {
auto pcArrowHeadTranslation = new SoTranslation();
pcArrowHeadTranslation->translation.setValue(0.0, cylinderOffset, 0.0);
auto pcArrowHead = new SoCone();
pcArrowHead->bottomRadius = arrowHeadRadius;
pcArrowHead->height = arrowHeadHeight;
auto pcArrowHeadSeparator = new SoSeparator();
pcArrowHeadSeparator->addChild(pcArrowHeadTranslation);
pcArrowHeadSeparator->addChild(pcArrowHead);
sep->addChild(pcArrowHeadSeparator);
}
if (parts.getValue() & Labels) {
auto pcLabelSeparator = new SoSeparator();
auto pcLabelTranslation = new SoTranslation();
pcLabelTranslation->translation.setValue(0.0, cylinderOffset + labelOffset, 0.0);
pcLabelSeparator->addChild(pcLabelTranslation);
auto pcAxisLabel = new SoFrameLabel();
pcAxisLabel->string.setValue(label);
pcAxisLabel->textColor.setValue(1.0, 1.0, 1.0);
pcAxisLabel->horAlignment = SoImage::CENTER;
pcAxisLabel->vertAlignment = SoImage::HALF;
pcAxisLabel->border = false;
pcAxisLabel->frame = false;
pcAxisLabel->textUseBaseColor = true;
pcAxisLabel->size = labelFontSize;
pcLabelSeparator->addChild(pcAxisLabel);
sep->addChild(pcLabelSeparator);
}
return sep;
};
double additionalAxisMargin = (parts.getValue() & OriginIndicator) ? axisThickness * 4 : 0;
double xyOffset = (parts.getValue() & PlaneIndicator)
? planeIndicatorRadius + planeIndicatorMargin
: axisMargin + additionalAxisMargin;
auto sep = new SoSeparator;
if (axes.getValue() & X) {
sep->addChild(createAxis("X",
Base::Vector3d::UnitX,
ViewParams::instance()->getAxisXColor(),
xyOffset));
}
if (axes.getValue() & Y) {
sep->addChild(createAxis("Y",
Base::Vector3d::UnitY,
ViewParams::instance()->getAxisYColor(),
xyOffset));
}
if (axes.getValue() & Z) {
double zOffset = (parts.getValue() & PlaneIndicator)
? planeIndicatorMargin
: axisMargin + additionalAxisMargin;
sep->addChild(createAxis("Z",
Base::Vector3d::UnitZ,
ViewParams::instance()->getAxisZColor(),
zOffset));
}
return sep;
}
SoSeparator* SoFCPlacementIndicatorKit::createPlaneIndicator()
{
// cylinders are aligned with Y axis for some reason
auto rotation = Base::Rotation(Base::Vector3d::UnitY, Base::Vector3d::UnitZ);
auto pcRotation = new SoRotation();
pcRotation->rotation = Base::convertTo<SbRotation>(rotation);
auto pcComplexity = new SoComplexity();
pcComplexity->value = 1.0f;
auto pcCylinder = new SoCylinder();
pcCylinder->height = 0.f;
pcCylinder->radius = planeIndicatorRadius;
pcCylinder->parts = SoCylinder::TOP;
const auto gray = Base::Color(0.75f, 0.75f, 0.75f);
auto pcMaterial = new SoMaterial();
pcMaterial->diffuseColor.setValue(Base::convertTo<SbColor>(gray));
pcMaterial->ambientColor.connectFrom(&pcMaterial->diffuseColor);
pcMaterial->transparency = planeIndicatorTransparency;
auto sep = new SoSeparator;
sep->addChild(pcRotation);
sep->addChild(pcMaterial);
sep->addChild(pcComplexity);
sep->addChild(pcCylinder);
return sep;
}
SoFCPlacementIndicatorKit::~SoFCPlacementIndicatorKit() = default;
} // namespace Gui
Reference in New Issue View Git Blame Copy Permalink