VisualizationMesh.cpp

Go to the documentation of this file.

#include "VisualizationMesh.h"
 
#include <Inventor/nodes/SoCoordinate3.h>
#include <Inventor/nodes/SoIndexedFaceSet.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/nodes/SoMaterialBinding.h>
#include <Inventor/nodes/SoNormal.h>
#include <Inventor/nodes/SoShapeHints.h>
 
namespace armarx::viz::coin
{
 
    VisualizationMesh::VisualizationMesh()
    {
        SoMaterialBinding* myBinding = new SoMaterialBinding;
        myBinding->value = SoMaterialBinding::PER_VERTEX_INDEXED;
 
        materials = new SoMaterial;
        coords = new SoCoordinate3;
 
        SoShapeHints* hints = new SoShapeHints;
        // Disable back culling and enable two-sided lighting
        hints->vertexOrdering = SoShapeHints::VertexOrdering::COUNTERCLOCKWISE;
        hints->shapeType = SoShapeHints::ShapeType::UNKNOWN_SHAPE_TYPE;
 
        faceSet = new SoIndexedFaceSet;
 
        node->addChild(myBinding);
        node->addChild(materials);
        node->addChild(coords);
        node->addChild(hints);
        node->addChild(faceSet);
    }
 
    bool
    VisualizationMesh::update(ElementType const& element)
    {
        int colorSize = (int)element.colors.size();
        bool noColorsArray = colorSize == 0;
        if (colorSize == 0)
        {
            colorSize = 1;
        }
        matColor.resize(colorSize);
        transp.resize(colorSize);
 
        const float conv = 1.0f / 255.0f;
        if (noColorsArray)
        {
            auto color = element.color;
            float r = color.r * conv;
            float g = color.g * conv;
            float b = color.b * conv;
            float a = color.a * conv;
            matColor[0].setValue(r, g, b);
            transp[0] = 1.0f - a;
        }
        else
        {
            for (int i = 0; i < colorSize; i++)
            {
                auto color = element.colors[i];
                float r = color.r * conv;
                float g = color.g * conv;
                float b = color.b * conv;
                float a = color.a * conv;
                matColor[i].setValue(r, g, b);
                transp[i] = 1.0f - a;
            }
        }
 
        // Define colors for the faces
        materials->diffuseColor.setValuesPointer(colorSize, matColor.data());
        materials->ambientColor.setValuesPointer(colorSize, matColor.data());
        materials->transparency.setValuesPointer(colorSize, transp.data());
 
        // define vertex array
        int vertexSize = (int)element.vertices.size();
        vertexPositions.resize(vertexSize);
        for (int i = 0; i < vertexSize; i++)
        {
            auto v = element.vertices[i];
            vertexPositions[i].setValue(v.e0, v.e1, v.e2);
        }
 
        // Define coordinates for vertices
        coords->point.setValuesPointer(vertexSize, vertexPositions.data());
 
        int facesSize = (int)element.faces.size();
        faces.resize(facesSize * 4);
        matInx.resize(facesSize * 4);
 
        for (int i = 0; i < facesSize; i++)
        {
            auto& face = element.faces[i];
 
            faces[i * 4 + 0] = face.v0;
            faces[i * 4 + 1] = face.v1;
            faces[i * 4 + 2] = face.v2;
            faces[i * 4 + 3] = SO_END_FACE_INDEX;
 
            matInx[i * 4 + 0] = face.c0;
            matInx[i * 4 + 1] = face.c1;
            matInx[i * 4 + 2] = face.c2;
            matInx[i * 4 + 3] = SO_END_FACE_INDEX;
        }
 
        faceSet->coordIndex.setValuesPointer(faces.size(), faces.data());
        faceSet->materialIndex.setValuesPointer(matInx.size(), matInx.data());
 
        return true;
    }
} // namespace armarx::viz::coin