FreeCAD / src /Gui /AxisOrigin.cpp

Upload folder using huggingface_hub

985c397 verified 9 months ago

7.02 kB

/****************************************************************************
 *   Copyright (c) 2019 Zheng Lei (realthunder) <realthunder.dev@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 <Inventor/nodes/SoCoordinate3.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoSwitch.h>
#include <Inventor/SoPickedPoint.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/nodes/SoMaterialBinding.h>
#include <Inventor/nodes/SoDrawStyle.h>
#include <Inventor/nodes/SoIndexedLineSet.h>
#include <Inventor/nodes/SoIndexedPointSet.h>
#include <Inventor/nodes/SoDrawStyle.h>
#include <Inventor/SoFullPath.h>

#include "Inventor/SoAutoZoomTranslation.h"
#include "SoFCSelection.h"
#include "SoFCUnifiedSelection.h"
#include "AxisOrigin.h"

using namespace Gui;

TYPESYSTEM_SOURCE(Gui::AxisOrigin, Base::BaseClass)

AxisOrigin::AxisOrigin() = default;

SoGroup* AxisOrigin::getNode()
{
    if (node) {
        return node;
    }

    node.reset(new SoGroup);
    auto pMat = new SoMaterial();

    const SbVec3f verts[13] = {
        SbVec3f(0, 0, 0),
        SbVec3f(size, 0, 0),
        SbVec3f(0, size, 0),
        SbVec3f(0, 0, size),
        SbVec3f(dist, dist, 0),
        SbVec3f(dist, pSize, 0),
        SbVec3f(pSize, dist, 0),  // XY Plane
        SbVec3f(dist, 0, dist),
        SbVec3f(dist, 0, pSize),
        SbVec3f(pSize, 0, dist),  // XY Plane
        SbVec3f(0, dist, dist),
        SbVec3f(0, pSize, dist),
        SbVec3f(0, dist, pSize)  // XY Plane
    };

    // indexes used to create the edges
    const int32_t lines[21] = {0, 1,  -1, 0, 2, -1, 0,  3,  -1, 5, 4,
                               6, -1, 8,  7, 9, -1, 11, 10, 12, -1};

    pMat->diffuseColor.setNum(3);
    pMat->diffuseColor.set1Value(0, SbColor(1.0f, 0.2f, 0.2f));
    pMat->diffuseColor.set1Value(1, SbColor(0.2f, 0.6f, 0.2f));
    pMat->diffuseColor.set1Value(2, SbColor(0.2f, 0.2f, 1.0f));
    pMat->diffuseColor.set1Value(4, SbColor(0.8f, 0.8f, 0.8f));

    auto pCoords = new SoCoordinate3();
    pCoords->point.setNum(3);
    pCoords->point.setValues(0, 13, verts);

    auto zoom = new SoAutoZoomTranslation;
    zoom->scaleFactor = scale;

    auto style = new SoDrawStyle();
    style->lineWidth = lineSize;
    style->pointSize = pointSize;

    auto matBinding = new SoMaterialBinding;
    matBinding->value = SoMaterialBinding::PER_FACE_INDEXED;

    node->addChild(zoom);
    node->addChild(style);
    node->addChild(matBinding);
    node->addChild(pMat);
    node->addChild(pCoords);

#define CREATE_AXIS(_type, _key, _count, _offset, _mat) \
    do { \
        const char* label = _key; \
        if (labels.size()) { \
            auto iter = labels.find(_key); \
            if (iter == labels.end()) \
                break; \
            else if (iter->second.size()) \
                label = iter->second.c_str(); \
        } \
        auto pAxis = new SoFCSelection; \
        pAxis->applySettings(); \
        pAxis->style = SoFCSelection::EMISSIVE_DIFFUSE; \
        pAxis->subElementName = label; \
        nodeMap[label].reset(pAxis); \
        node->addChild(pAxis); \
        auto _type = new SoIndexed##_type##Set; \
        pAxis->addChild(_type); \
        _type->coordIndex.setNum(_count); \
        _type->coordIndex.setValues(0, _count, lines + _offset); \
        _type->materialIndex.setValue(_mat); \
    } while (0)

    CREATE_AXIS(Point, "O", 1, 0, 4);
    CREATE_AXIS(Line, "X", 3, 0, 0);
    CREATE_AXIS(Line, "Y", 3, 3, 1);
    CREATE_AXIS(Line, "Z", 3, 6, 2);
    CREATE_AXIS(Line, "XY", 4, 9, 2);
    CREATE_AXIS(Line, "XZ", 4, 13, 1);
    CREATE_AXIS(Line, "YZ", 4, 17, 0);
    return node;
}

bool AxisOrigin::getElementPicked(const SoPickedPoint* pp, std::string& subname) const
{
    SoPath* path = pp->getPath();
    int length = path->getLength();
    for (int i = 0; i < length; ++i) {
        auto node = path->getNodeFromTail(i);
        if (node->isOfType(SoFCSelection::getClassTypeId())) {
            subname = static_cast<SoFCSelection*>(node)->subElementName.getValue().getString();
            return true;
        }
        else if (node->isOfType(SoFCSelectionRoot::getClassTypeId())) {
            break;
        }
    }
    return false;
}

bool AxisOrigin::getDetailPath(const char* subname, SoFullPath* pPath, SoDetail*&) const
{
    if (!node) {
        return false;
    }
    if (!subname || !subname[0]) {
        return true;
    }

    auto it = nodeMap.find(subname);
    if (it == nodeMap.end()) {
        return false;
    }
    pPath->append(node);
    pPath->append(it->second);
    return true;
}

void AxisOrigin::setLineWidth(float size)
{
    if (size != lineSize) {
        node.reset();
        nodeMap.clear();
        lineSize = size;
    }
}

void AxisOrigin::setPointSize(float size)
{
    if (pointSize != size) {
        pointSize = size;
        node.reset();
        nodeMap.clear();
    }
}

void AxisOrigin::setAxisLength(float size)
{
    if (this->size != size) {
        this->size = size;
        node.reset();
        nodeMap.clear();
    }
}

void AxisOrigin::setPlane(float size, float dist)
{
    if (pSize != size || this->dist != dist) {
        pSize = size;
        this->dist = dist;
        node.reset();
        nodeMap.clear();
    }
}

void AxisOrigin::setScale(float scale)
{
    if (this->scale != scale) {
        this->scale = scale;
        node.reset();
        nodeMap.clear();
    }
}

void AxisOrigin::setLabels(const std::map<std::string, std::string>& labels)
{
    this->labels = labels;
    node.reset();
    nodeMap.clear();
}

	/****************************************************************************
	* Copyright (c) 2019 Zheng Lei (realthunder) <realthunder.dev@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 <Inventor/nodes/SoCoordinate3.h>
	#include <Inventor/nodes/SoSeparator.h>
	#include <Inventor/nodes/SoSwitch.h>
	#include <Inventor/SoPickedPoint.h>
	#include <Inventor/nodes/SoMaterial.h>
	#include <Inventor/nodes/SoMaterialBinding.h>
	#include <Inventor/nodes/SoDrawStyle.h>
	#include <Inventor/nodes/SoIndexedLineSet.h>
	#include <Inventor/nodes/SoIndexedPointSet.h>
	#include <Inventor/nodes/SoDrawStyle.h>
	#include <Inventor/SoFullPath.h>

	#include "Inventor/SoAutoZoomTranslation.h"
	#include "SoFCSelection.h"
	#include "SoFCUnifiedSelection.h"
	#include "AxisOrigin.h"

	using namespace Gui;

	TYPESYSTEM_SOURCE(Gui::AxisOrigin, Base::BaseClass)

	AxisOrigin::AxisOrigin() = default;

	SoGroup* AxisOrigin::getNode()
	{
	if (node) {
	return node;
	}

	node.reset(new SoGroup);
	auto pMat = new SoMaterial();

	const SbVec3f verts[13] = {
	SbVec3f(0, 0, 0),
	SbVec3f(size, 0, 0),
	SbVec3f(0, size, 0),
	SbVec3f(0, 0, size),
	SbVec3f(dist, dist, 0),
	SbVec3f(dist, pSize, 0),
	SbVec3f(pSize, dist, 0), // XY Plane
	SbVec3f(dist, 0, dist),
	SbVec3f(dist, 0, pSize),
	SbVec3f(pSize, 0, dist), // XY Plane
	SbVec3f(0, dist, dist),
	SbVec3f(0, pSize, dist),
	SbVec3f(0, dist, pSize) // XY Plane
	};

	// indexes used to create the edges
	const int32_t lines[21] = {0, 1, -1, 0, 2, -1, 0, 3, -1, 5, 4,
	6, -1, 8, 7, 9, -1, 11, 10, 12, -1};

	pMat->diffuseColor.setNum(3);
	pMat->diffuseColor.set1Value(0, SbColor(1.0f, 0.2f, 0.2f));
	pMat->diffuseColor.set1Value(1, SbColor(0.2f, 0.6f, 0.2f));
	pMat->diffuseColor.set1Value(2, SbColor(0.2f, 0.2f, 1.0f));
	pMat->diffuseColor.set1Value(4, SbColor(0.8f, 0.8f, 0.8f));

	auto pCoords = new SoCoordinate3();
	pCoords->point.setNum(3);
	pCoords->point.setValues(0, 13, verts);

	auto zoom = new SoAutoZoomTranslation;
	zoom->scaleFactor = scale;

	auto style = new SoDrawStyle();
	style->lineWidth = lineSize;
	style->pointSize = pointSize;

	auto matBinding = new SoMaterialBinding;
	matBinding->value = SoMaterialBinding::PER_FACE_INDEXED;

	node->addChild(zoom);
	node->addChild(style);
	node->addChild(matBinding);
	node->addChild(pMat);
	node->addChild(pCoords);

	#define CREATE_AXIS(_type, _key, _count, _offset, _mat) \
	do { \
	const char* label = _key; \
	if (labels.size()) { \
	auto iter = labels.find(_key); \
	if (iter == labels.end()) \
	break; \
	else if (iter->second.size()) \
	label = iter->second.c_str(); \
	} \
	auto pAxis = new SoFCSelection; \
	pAxis->applySettings(); \
	pAxis->style = SoFCSelection::EMISSIVE_DIFFUSE; \
	pAxis->subElementName = label; \
	nodeMap[label].reset(pAxis); \
	node->addChild(pAxis); \
	auto _type = new SoIndexed##_type##Set; \
	pAxis->addChild(_type); \
	_type->coordIndex.setNum(_count); \
	_type->coordIndex.setValues(0, _count, lines + _offset); \
	_type->materialIndex.setValue(_mat); \
	} while (0)

	CREATE_AXIS(Point, "O", 1, 0, 4);
	CREATE_AXIS(Line, "X", 3, 0, 0);
	CREATE_AXIS(Line, "Y", 3, 3, 1);
	CREATE_AXIS(Line, "Z", 3, 6, 2);
	CREATE_AXIS(Line, "XY", 4, 9, 2);
	CREATE_AXIS(Line, "XZ", 4, 13, 1);
	CREATE_AXIS(Line, "YZ", 4, 17, 0);
	return node;
	}

	bool AxisOrigin::getElementPicked(const SoPickedPoint* pp, std::string& subname) const
	{
	SoPath* path = pp->getPath();
	int length = path->getLength();
	for (int i = 0; i < length; ++i) {
	auto node = path->getNodeFromTail(i);
	if (node->isOfType(SoFCSelection::getClassTypeId())) {
	subname = static_cast<SoFCSelection*>(node)->subElementName.getValue().getString();
	return true;
	}
	else if (node->isOfType(SoFCSelectionRoot::getClassTypeId())) {
	break;
	}
	}
	return false;
	}

	bool AxisOrigin::getDetailPath(const char* subname, SoFullPath* pPath, SoDetail*&) const
	{
	if (!node) {
	return false;
	}
	if (!subname \|\| !subname[0]) {
	return true;
	}

	auto it = nodeMap.find(subname);
	if (it == nodeMap.end()) {
	return false;
	}
	pPath->append(node);
	pPath->append(it->second);
	return true;
	}

	void AxisOrigin::setLineWidth(float size)
	{
	if (size != lineSize) {
	node.reset();
	nodeMap.clear();
	lineSize = size;
	}
	}

	void AxisOrigin::setPointSize(float size)
	{
	if (pointSize != size) {
	pointSize = size;
	node.reset();
	nodeMap.clear();
	}
	}

	void AxisOrigin::setAxisLength(float size)
	{
	if (this->size != size) {
	this->size = size;
	node.reset();
	nodeMap.clear();
	}
	}

	void AxisOrigin::setPlane(float size, float dist)
	{
	if (pSize != size \|\| this->dist != dist) {
	pSize = size;
	this->dist = dist;
	node.reset();
	nodeMap.clear();
	}
	}

	void AxisOrigin::setScale(float scale)
	{
	if (this->scale != scale) {
	this->scale = scale;
	node.reset();
	nodeMap.clear();
	}
	}

	void AxisOrigin::setLabels(const std::map<std::string, std::string>& labels)
	{
	this->labels = labels;
	node.reset();
	nodeMap.clear();
	}