504 lines
23 KiB
C++
504 lines
23 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 2021 Abdullah Tahiri <abdullah.tahiri.yo@gmail.com> *
|
|
* *
|
|
* 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 "PreCompiled.h"
|
|
#ifndef _PreComp_
|
|
# include <memory>
|
|
|
|
# include <Inventor/SbVec3f.h>
|
|
# include <Inventor/nodes/SoCoordinate3.h>
|
|
# include <Inventor/nodes/SoDrawStyle.h>
|
|
# include <Inventor/nodes/SoLineSet.h>
|
|
# include <Inventor/nodes/SoMarkerSet.h>
|
|
# include <Inventor/nodes/SoMaterial.h>
|
|
# include <Inventor/nodes/SoSeparator.h>
|
|
#endif // #ifndef _PreComp_
|
|
|
|
#include <Gui/Inventor/MarkerBitmaps.h>
|
|
#include <Gui/Inventor/SmSwitchboard.h>
|
|
#include <Mod/Sketcher/App/Constraint.h>
|
|
#include <Mod/Sketcher/App/GeoEnum.h>
|
|
#include <Mod/Sketcher/App/GeoList.h>
|
|
#include <Mod/Sketcher/App/GeometryFacade.h>
|
|
#include <Mod/Sketcher/App/SolverGeometryExtension.h>
|
|
|
|
#include "EditModeGeometryCoinManager.h"
|
|
#include "EditModeGeometryCoinConverter.h"
|
|
#include "ViewProviderSketchCoinAttorney.h"
|
|
|
|
|
|
using namespace SketcherGui;
|
|
using namespace Sketcher;
|
|
|
|
//**************************** EditModeGeometryCoinManager class ******************************
|
|
|
|
EditModeGeometryCoinManager::EditModeGeometryCoinManager( ViewProviderSketch &vp,
|
|
DrawingParameters & drawingParams,
|
|
GeometryLayerParameters & geometryLayerParams,
|
|
AnalysisResults & analysisResultStruct,
|
|
EditModeScenegraphNodes & editModeScenegraph,
|
|
CoinMapping & coinMap):
|
|
viewProvider(vp),
|
|
drawingParameters(drawingParams),
|
|
geometryLayerParameters(geometryLayerParams),
|
|
analysisResults(analysisResultStruct),
|
|
editModeScenegraphNodes(editModeScenegraph),
|
|
coinMapping(coinMap)
|
|
{}
|
|
|
|
EditModeGeometryCoinManager::~EditModeGeometryCoinManager()
|
|
{}
|
|
|
|
void EditModeGeometryCoinManager::processGeometry(const GeoListFacade & geolistfacade)
|
|
{
|
|
// enable all layers
|
|
editModeScenegraphNodes.PointsGroup->enable.setNum(geometryLayerParameters.CoinLayers);
|
|
editModeScenegraphNodes.CurvesGroup->enable.setNum(geometryLayerParameters.CoinLayers);
|
|
SbBool *swsp = editModeScenegraphNodes.PointsGroup->enable.startEditing();
|
|
SbBool *swsc = editModeScenegraphNodes.CurvesGroup->enable.startEditing();
|
|
|
|
for(int l=0; l<geometryLayerParameters.CoinLayers; l++){
|
|
swsp[l] = true; // layer defaults to enabled
|
|
swsc[l] = true; // layer defaults to enabled
|
|
}
|
|
|
|
editModeScenegraphNodes.PointsGroup->enable.finishEditing();
|
|
editModeScenegraphNodes.CurvesGroup->enable.finishEditing();
|
|
|
|
// Define the coin nodes that will be filled in with the geometry layers
|
|
GeometryLayerNodes geometrylayernodes {
|
|
editModeScenegraphNodes.PointsMaterials,
|
|
editModeScenegraphNodes.PointsCoordinate,
|
|
editModeScenegraphNodes.CurvesMaterials,
|
|
editModeScenegraphNodes.CurvesCoordinate,
|
|
editModeScenegraphNodes.CurveSet
|
|
};
|
|
|
|
// process geometry layers
|
|
EditModeGeometryCoinConverter gcconv(viewProvider, geometrylayernodes, drawingParameters, geometryLayerParameters, coinMapping);
|
|
|
|
gcconv.convert(geolistfacade);
|
|
|
|
// set cross coordinates
|
|
editModeScenegraphNodes.RootCrossSet->numVertices.set1Value(0,2);
|
|
editModeScenegraphNodes.RootCrossSet->numVertices.set1Value(1,2);
|
|
|
|
analysisResults.combRepresentationScale = gcconv.getCombRepresentationScale();
|
|
analysisResults.boundingBoxMagnitudeOrder = exp(ceil(log(std::abs(gcconv.getBoundingBoxMaxMagnitude()))));
|
|
analysisResults.bsplineGeoIds = gcconv.getBSplineGeoIds();
|
|
}
|
|
|
|
void EditModeGeometryCoinManager::updateGeometryColor(const GeoListFacade & geolistfacade, bool issketchinvalid)
|
|
{
|
|
// Lambdas for convenience retrieval of geometry information
|
|
auto isConstructionGeom = [&geolistfacade](int GeoId) {
|
|
auto geom = geolistfacade.getGeometryFacadeFromGeoId(GeoId);
|
|
if (geom)
|
|
return geom->getConstruction();
|
|
return false;
|
|
};
|
|
|
|
auto isDefinedGeomPoint = [&geolistfacade](int GeoId) {
|
|
auto geom = geolistfacade.getGeometryFacadeFromGeoId(GeoId);
|
|
if (geom)
|
|
return geom->isGeoType(Part::GeomPoint::getClassTypeId()) && !geom->getConstruction();
|
|
return false;
|
|
};
|
|
|
|
auto isInternalAlignedGeom = [&geolistfacade](int GeoId) {
|
|
auto geom = geolistfacade.getGeometryFacadeFromGeoId(GeoId);
|
|
if (geom) {
|
|
return geom->isInternalAligned();
|
|
}
|
|
return false;
|
|
};
|
|
|
|
auto isFullyConstraintElement = [&geolistfacade](int GeoId) {
|
|
auto geom = geolistfacade.getGeometryFacadeFromGeoId(GeoId);
|
|
|
|
if(geom) {
|
|
if(geom->hasExtension(Sketcher::SolverGeometryExtension::getClassTypeId())) {
|
|
|
|
auto solvext = std::static_pointer_cast<const Sketcher::SolverGeometryExtension>(
|
|
geom->getExtension(Sketcher::SolverGeometryExtension::getClassTypeId()).lock());
|
|
|
|
return (solvext->getGeometry() == Sketcher::SolverGeometryExtension::FullyConstraint);
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
// Update Colors
|
|
|
|
SbColor *crosscolor = editModeScenegraphNodes.RootCrossMaterials->diffuseColor.startEditing();
|
|
auto viewOrientationFactor = ViewProviderSketchCoinAttorney::getViewOrientationFactor(viewProvider);
|
|
|
|
for(int l=0; l<geometryLayerParameters.CoinLayers; l++) {
|
|
|
|
int PtNum = editModeScenegraphNodes.PointsMaterials[l]->diffuseColor.getNum();
|
|
SbColor *pcolor = editModeScenegraphNodes.PointsMaterials[l]->diffuseColor.startEditing();
|
|
int CurvNum = editModeScenegraphNodes.CurvesMaterials[l]->diffuseColor.getNum();
|
|
SbColor *color = editModeScenegraphNodes.CurvesMaterials[l]->diffuseColor.startEditing();
|
|
|
|
SbVec3f *verts = editModeScenegraphNodes.CurvesCoordinate[l]->point.startEditing();
|
|
SbVec3f *pverts = editModeScenegraphNodes.PointsCoordinate[l]->point.startEditing();
|
|
|
|
float x,y,z;
|
|
|
|
// colors of the point set
|
|
if( issketchinvalid ) {
|
|
for (int i=0; i < PtNum; i++)
|
|
pcolor[i] = drawingParameters.InvalidSketchColor;
|
|
}
|
|
else {
|
|
|
|
for (int i=0; i < PtNum; i++) {
|
|
if ( !(i == 0 && l == 0) && ViewProviderSketchCoinAttorney::isSketchFullyConstrained(viewProvider)) {// root point is not coloured
|
|
pcolor[i] = drawingParameters.FullyConstrainedColor;
|
|
}
|
|
else {
|
|
int GeoId = coinMapping.getPointGeoId(i, l);
|
|
|
|
bool constrainedElement = isFullyConstraintElement(GeoId);
|
|
|
|
if(isInternalAlignedGeom(GeoId)) {
|
|
if(constrainedElement)
|
|
pcolor[i] = drawingParameters.FullyConstraintInternalAlignmentColor;
|
|
else
|
|
pcolor[i] = drawingParameters.InternalAlignedGeoColor;
|
|
}
|
|
else {
|
|
if(!isDefinedGeomPoint(GeoId)) {
|
|
if(constrainedElement)
|
|
pcolor[i] = drawingParameters.FullyConstraintConstructionPointColor;
|
|
else
|
|
pcolor[i] = drawingParameters.VertexColor;
|
|
}
|
|
else { // this is a defined GeomPoint
|
|
if(constrainedElement)
|
|
pcolor[i] = drawingParameters.FullyConstraintElementColor;
|
|
else
|
|
pcolor[i] = drawingParameters.CurveColor;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// update rendering height of points
|
|
|
|
auto getRenderHeight = [this](DrawingParameters::GeometryRendering renderingtype, float toprendering, float midrendering, float lowrendering) {
|
|
if(drawingParameters.topRenderingGeometry == renderingtype)
|
|
return toprendering;
|
|
else if(drawingParameters.midRenderingGeometry == renderingtype)
|
|
return midrendering;
|
|
else
|
|
return lowrendering;
|
|
};
|
|
|
|
float zNormPoint = getRenderHeight(DrawingParameters::GeometryRendering::NormalGeometry,
|
|
drawingParameters.zHighPoints,
|
|
drawingParameters.zLowPoints,
|
|
drawingParameters.zLowPoints);
|
|
|
|
float zConstrPoint = getRenderHeight(DrawingParameters::GeometryRendering::Construction,
|
|
drawingParameters.zHighPoints,
|
|
drawingParameters.zLowPoints,
|
|
drawingParameters.zLowPoints);
|
|
|
|
for (int i=0; i < PtNum; i++) { // 0 is the origin
|
|
if( i == 0 && l == 0 ) { // reset root point to lowest
|
|
pverts[i].setValue(0, 0, viewOrientationFactor * drawingParameters.zRootPoint);
|
|
}
|
|
else {
|
|
pverts[i].getValue(x,y,z);
|
|
auto geom = geolistfacade.getGeometryFacadeFromGeoId(coinMapping.getPointGeoId(i, l));
|
|
|
|
if(geom) {
|
|
if(geom->getConstruction())
|
|
pverts[i].setValue(x,y,viewOrientationFactor * zConstrPoint);
|
|
else
|
|
pverts[i].setValue(x,y,viewOrientationFactor * zNormPoint);
|
|
}
|
|
}
|
|
}
|
|
|
|
auto preselectpoint = ViewProviderSketchCoinAttorney::getPreselectPoint(viewProvider);
|
|
auto preselectcross = ViewProviderSketchCoinAttorney::getPreselectCross(viewProvider);
|
|
auto preselectcurve = ViewProviderSketchCoinAttorney::getPreselectCurve(viewProvider);
|
|
|
|
MultiFieldId preselectpointmfid;
|
|
|
|
if ( preselectcross == 0) {
|
|
if(l == 0) // cross only in layer 0
|
|
pcolor[0] = drawingParameters.PreselectColor;
|
|
}
|
|
else if (preselectpoint != -1) {
|
|
preselectpointmfid = coinMapping.getIndexLayer(preselectpoint);
|
|
if (MultiFieldId::Invalid != preselectpointmfid &&
|
|
preselectpointmfid.layerId == l &&
|
|
preselectpointmfid.fieldIndex < PtNum)
|
|
pcolor[preselectpointmfid.fieldIndex] = drawingParameters.PreselectColor;
|
|
}
|
|
|
|
ViewProviderSketchCoinAttorney::executeOnSelectionPointSet(viewProvider,
|
|
[pcolor, PtNum, preselectpointmfid, layerId = l, &coinMapping = coinMapping, drawingParameters = this->drawingParameters](const int i) {
|
|
auto pointindex = coinMapping.getIndexLayer(i);
|
|
if (layerId == pointindex.layerId && pointindex.fieldIndex >= 0 && pointindex.fieldIndex < PtNum) {
|
|
pcolor[pointindex.fieldIndex] = (preselectpointmfid == pointindex)
|
|
? drawingParameters.PreselectSelectedColor : drawingParameters.SelectColor;
|
|
}
|
|
});
|
|
|
|
// update colors and rendering height of the curves
|
|
|
|
float zNormLine = getRenderHeight(DrawingParameters::GeometryRendering::NormalGeometry,
|
|
drawingParameters.zHighLines,
|
|
drawingParameters.zMidLines,
|
|
drawingParameters.zLowLines);
|
|
|
|
float zConstrLine = getRenderHeight(DrawingParameters::GeometryRendering::Construction,
|
|
drawingParameters.zHighLines,
|
|
drawingParameters.zMidLines,
|
|
drawingParameters.zLowLines);
|
|
|
|
float zExtLine = getRenderHeight(DrawingParameters::GeometryRendering::ExternalGeometry,
|
|
drawingParameters.zHighLines,
|
|
drawingParameters.zMidLines,
|
|
drawingParameters.zLowLines);
|
|
|
|
int j=0; // vertexindex
|
|
|
|
for (int i=0; i < CurvNum; i++) {
|
|
int GeoId = coinMapping.getCurveGeoId(i, l);
|
|
// CurvId has several vertices associated to 1 material
|
|
//edit->CurveSet->numVertices => [i] indicates number of vertex for line i.
|
|
int indexes = (editModeScenegraphNodes.CurveSet[l]->numVertices[i]);
|
|
|
|
bool selected = ViewProviderSketchCoinAttorney::isCurveSelected(viewProvider, GeoId);
|
|
bool preselected = (preselectcurve == GeoId);
|
|
|
|
bool constrainedElement = isFullyConstraintElement(GeoId);
|
|
|
|
if (selected && preselected) {
|
|
color[i] = drawingParameters.PreselectSelectedColor;
|
|
for (int k=j; j<k+indexes; j++) {
|
|
verts[j].getValue(x,y,z);
|
|
verts[j] = SbVec3f(x,y,viewOrientationFactor * drawingParameters.zHighLine);
|
|
}
|
|
}
|
|
else if (selected){
|
|
color[i] = drawingParameters.SelectColor;
|
|
for (int k=j; j<k+indexes; j++) {
|
|
verts[j].getValue(x,y,z);
|
|
verts[j] = SbVec3f(x,y,viewOrientationFactor * drawingParameters.zHighLine);
|
|
}
|
|
}
|
|
else if (preselected){
|
|
color[i] = drawingParameters.PreselectColor;
|
|
for (int k=j; j<k+indexes; j++) {
|
|
verts[j].getValue(x,y,z);
|
|
verts[j] = SbVec3f(x,y,viewOrientationFactor * drawingParameters.zHighLine);
|
|
}
|
|
}
|
|
else if (GeoId <= Sketcher::GeoEnum::RefExt) { // external Geometry
|
|
color[i] = drawingParameters.CurveExternalColor;
|
|
for (int k=j; j<k+indexes; j++) {
|
|
verts[j].getValue(x,y,z);
|
|
verts[j] = SbVec3f(x,y,viewOrientationFactor * zExtLine);
|
|
}
|
|
}
|
|
else if ( issketchinvalid ) {
|
|
color[i] = drawingParameters.InvalidSketchColor;
|
|
for (int k=j; j<k+indexes; j++) {
|
|
verts[j].getValue(x,y,z);
|
|
verts[j] = SbVec3f(x,y,viewOrientationFactor * zNormLine);
|
|
}
|
|
}
|
|
else if (isConstructionGeom(GeoId)) {
|
|
if(isInternalAlignedGeom(GeoId)) {
|
|
if(constrainedElement)
|
|
color[i] = drawingParameters.FullyConstraintInternalAlignmentColor;
|
|
else
|
|
color[i] = drawingParameters.InternalAlignedGeoColor;
|
|
}
|
|
else {
|
|
if(constrainedElement)
|
|
color[i] = drawingParameters.FullyConstraintConstructionElementColor;
|
|
else
|
|
color[i] = drawingParameters.CurveDraftColor;
|
|
}
|
|
|
|
for (int k=j; j<k+indexes; j++) {
|
|
verts[j].getValue(x,y,z);
|
|
verts[j] = SbVec3f(x,y,viewOrientationFactor * zConstrLine);
|
|
}
|
|
}
|
|
else if (ViewProviderSketchCoinAttorney::isSketchFullyConstrained(viewProvider)) {
|
|
color[i] = drawingParameters.FullyConstrainedColor;
|
|
for (int k=j; j<k+indexes; j++) {
|
|
verts[j].getValue(x,y,z);
|
|
verts[j] = SbVec3f(x,y,viewOrientationFactor * zNormLine);
|
|
}
|
|
}
|
|
else if (isFullyConstraintElement(GeoId)) {
|
|
color[i] = drawingParameters.FullyConstraintElementColor;
|
|
for (int k=j; j<k+indexes; j++) {
|
|
verts[j].getValue(x,y,z);
|
|
verts[j] = SbVec3f(x,y,viewOrientationFactor * zNormLine);
|
|
}
|
|
}
|
|
else {
|
|
color[i] = drawingParameters.CurveColor;
|
|
for (int k=j; j<k+indexes; j++) {
|
|
verts[j].getValue(x,y,z);
|
|
verts[j] = SbVec3f(x,y,viewOrientationFactor * zNormLine);
|
|
}
|
|
}
|
|
}
|
|
|
|
// colors of the cross
|
|
if ( l == 0 ) { // only in layer 0
|
|
if (ViewProviderSketchCoinAttorney::isCurveSelected(viewProvider, Sketcher::GeoEnum::HAxis)) {
|
|
crosscolor[0] = drawingParameters.SelectColor;
|
|
}
|
|
else if (preselectcross == 1) { // cross only in layer 0
|
|
crosscolor[0] = drawingParameters.PreselectColor;
|
|
}
|
|
else {
|
|
crosscolor[0] = drawingParameters.CrossColorH;
|
|
}
|
|
|
|
if (ViewProviderSketchCoinAttorney::isCurveSelected(viewProvider, Sketcher::GeoEnum::VAxis)) {
|
|
crosscolor[1] = drawingParameters.SelectColor;
|
|
}
|
|
else if (preselectcross == 2) {
|
|
crosscolor[1] = drawingParameters.PreselectColor;
|
|
}
|
|
else {
|
|
crosscolor[1] = drawingParameters.CrossColorV;
|
|
}
|
|
}
|
|
|
|
// end editing
|
|
editModeScenegraphNodes.CurvesMaterials[l]->diffuseColor.finishEditing();
|
|
editModeScenegraphNodes.PointsMaterials[l]->diffuseColor.finishEditing();
|
|
editModeScenegraphNodes.CurvesCoordinate[l]->point.finishEditing();
|
|
editModeScenegraphNodes.CurveSet[l]->numVertices.finishEditing();
|
|
}
|
|
|
|
editModeScenegraphNodes.RootCrossMaterials->diffuseColor.finishEditing();
|
|
}
|
|
|
|
|
|
void EditModeGeometryCoinManager::createEditModeInventorNodes()
|
|
{
|
|
// stuff for the points ++++++++++++++++++++++++++++++++++++++
|
|
editModeScenegraphNodes.PointsGroup = new SmSwitchboard;
|
|
editModeScenegraphNodes.EditRoot->addChild(editModeScenegraphNodes.PointsGroup);
|
|
|
|
auto concat = [](std::string string, int i) {
|
|
return string+std::to_string(i);
|
|
};
|
|
|
|
for(int i=0; i < geometryLayerParameters.CoinLayers; i++) {
|
|
SoSeparator * sep = new SoSeparator;
|
|
sep->ref();
|
|
|
|
auto somaterial = new SoMaterial;
|
|
editModeScenegraphNodes.PointsMaterials.push_back(somaterial);
|
|
editModeScenegraphNodes.PointsMaterials[i]->setName(concat("PointsMaterials_",i).c_str());
|
|
sep->addChild(editModeScenegraphNodes.PointsMaterials[i]);
|
|
|
|
SoMaterialBinding *MtlBind = new SoMaterialBinding;
|
|
MtlBind->setName(concat("PointsMaterialBinding",i).c_str());
|
|
MtlBind->value = SoMaterialBinding::PER_VERTEX;
|
|
sep->addChild(MtlBind);
|
|
|
|
auto coords = new SoCoordinate3;
|
|
editModeScenegraphNodes.PointsCoordinate.push_back(coords);
|
|
editModeScenegraphNodes.PointsCoordinate[i]->setName(concat("PointsCoordinate",i).c_str());
|
|
sep->addChild(editModeScenegraphNodes.PointsCoordinate[i]);
|
|
|
|
auto drawstyle = new SoDrawStyle;
|
|
editModeScenegraphNodes.PointsDrawStyle.push_back(drawstyle);
|
|
editModeScenegraphNodes.PointsDrawStyle[i]->setName(concat("PointsDrawStyle",i).c_str());
|
|
editModeScenegraphNodes.PointsDrawStyle[i]->pointSize = 8 * drawingParameters.pixelScalingFactor;
|
|
sep->addChild(editModeScenegraphNodes.PointsDrawStyle[i]);
|
|
|
|
auto pointset = new SoMarkerSet;
|
|
editModeScenegraphNodes.PointSet.push_back(pointset);
|
|
editModeScenegraphNodes.PointSet[i]->setName(concat("PointSet",i).c_str());
|
|
editModeScenegraphNodes.PointSet[i]->markerIndex = Gui::Inventor::MarkerBitmaps::getMarkerIndex("CIRCLE_FILLED", drawingParameters.markerSize);
|
|
sep->addChild(editModeScenegraphNodes.PointSet[i]);
|
|
|
|
editModeScenegraphNodes.PointsGroup->addChild(sep);
|
|
sep->unref();
|
|
}
|
|
|
|
// stuff for the Curves +++++++++++++++++++++++++++++++++++++++
|
|
editModeScenegraphNodes.CurvesGroup = new SmSwitchboard;
|
|
editModeScenegraphNodes.EditRoot->addChild(editModeScenegraphNodes.CurvesGroup);
|
|
|
|
for(int i=0; i < geometryLayerParameters.CoinLayers; i++) {
|
|
SoSeparator * sep = new SoSeparator;
|
|
sep->ref();
|
|
|
|
auto somaterial = new SoMaterial;
|
|
editModeScenegraphNodes.CurvesMaterials.push_back(somaterial);
|
|
editModeScenegraphNodes.CurvesMaterials[i]->setName(concat("CurvesMaterials",i).c_str());
|
|
sep->addChild(editModeScenegraphNodes.CurvesMaterials[i]);
|
|
|
|
auto MtlBind = new SoMaterialBinding;
|
|
MtlBind->setName(concat("CurvesMaterialsBinding",i).c_str());
|
|
MtlBind->value = SoMaterialBinding::PER_FACE;
|
|
sep->addChild(MtlBind);
|
|
|
|
auto coords = new SoCoordinate3;
|
|
editModeScenegraphNodes.CurvesCoordinate.push_back(coords);
|
|
editModeScenegraphNodes.CurvesCoordinate[i]->setName(concat("CurvesCoordinate",i).c_str());
|
|
sep->addChild(editModeScenegraphNodes.CurvesCoordinate[i]);
|
|
|
|
auto drawstyle = new SoDrawStyle;
|
|
editModeScenegraphNodes.CurvesDrawStyle.push_back(drawstyle);
|
|
editModeScenegraphNodes.CurvesDrawStyle[i]->setName(concat("CurvesDrawStyle",i).c_str());
|
|
editModeScenegraphNodes.CurvesDrawStyle[i]->lineWidth = 3 * drawingParameters.pixelScalingFactor;
|
|
|
|
/* Demo code to introduce a dashed line
|
|
if(i == 1) {
|
|
editModeScenegraphNodes.CurvesDrawStyle[i]->linePattern = 0x3CF2;
|
|
editModeScenegraphNodes.CurvesDrawStyle[i]->linePatternScaleFactor = 5;
|
|
}*/
|
|
|
|
sep->addChild(editModeScenegraphNodes.CurvesDrawStyle[i]);
|
|
|
|
auto solineset = new SoLineSet;
|
|
editModeScenegraphNodes.CurveSet.push_back(solineset);
|
|
editModeScenegraphNodes.CurveSet[i]->setName(concat("CurvesLineSet",i).c_str());
|
|
sep->addChild(editModeScenegraphNodes.CurveSet[i]);
|
|
|
|
editModeScenegraphNodes.CurvesGroup->addChild(sep);
|
|
sep->unref();
|
|
}
|
|
|
|
}
|