source/SoFrictionCone.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2007, 2008, 2009, University of Karlsruhe (for members see AUTHORS file)
 *
 * ISC License
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "../include/IPSA/SoFrictionCone.h"

#include <Inventor/nodes/SoCone.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/nodes/SoTransform.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoResetTransform.h>

SO_KIT_SOURCE(SoFrictionCone);

std::string SoFrictionCone::FrictionConeSeparatorName = std::string("FrictionCones");

void SoFrictionCone::initClass()
{
                SO_KIT_INIT_CLASS(SoFrictionCone, SoBaseKit, "BaseKit");
}


SoFrictionCone::SoFrictionCone()
{
                SO_KIT_CONSTRUCTOR(SoFrictionCone);
                isBuiltIn = TRUE;

                SO_KIT_ADD_CATALOG_ENTRY(resetTransform,SoResetTransform,FALSE,this,offsetTransform,TRUE);
                SO_KIT_ADD_CATALOG_ENTRY(offsetTransform,SoTransform,FALSE,this,transform,TRUE);
                SO_KIT_ADD_CATALOG_ENTRY(transform,SoTransform,FALSE,this,material,TRUE);
                SO_KIT_ADD_CATALOG_ENTRY(material,SoMaterial,FALSE,this,visualisation,TRUE);
                SO_KIT_ADD_CATALOG_ENTRY(visualisation,SoCone,FALSE,this,"",TRUE);

                SO_KIT_ADD_FIELD(height, (1.0f));
                SO_KIT_ADD_FIELD(radius, (1.0f));
                SO_KIT_ADD_FIELD(scaling, (1.0f));
                SO_KIT_ADD_FIELD(transparency, (0.0f));
                SO_KIT_ADD_FIELD(color, (1.0f, 0.5f, 0.5f));
                SO_KIT_ADD_FIELD(contactPoint, (0.0f, 0.0f, 0.0f));
                SO_KIT_ADD_FIELD(contactNormal, (1.0f, 0.0f, 0.0f));

                SO_KIT_INIT_INSTANCE();

                updateParametersSensor.setFunction(SoFrictionCone::UpdateParametersCB);
                updateParametersSensor.setData(this);

                updateParametersTrigger.appendConnection(&height);
                updateParametersTrigger.appendConnection(&radius);
                updateParametersTrigger.appendConnection(&scaling);
                updateParametersTrigger.appendConnection(&transparency);
                updateParametersTrigger.appendConnection(&color);
                updateParametersTrigger.appendConnection(&contactPoint);
                updateParametersTrigger.appendConnection(&contactNormal);
                setUpConnections(TRUE, TRUE);
}


SoBaseKit* SoFrictionCone::copy(SbBool copyConnections) const
{
                // Use the standard version of the copy method to create a
                // copy of this instance, including its field data
                SoFrictionCone *newSoFrictionCone = (SoFrictionCone *) SoBaseKit::copy(copyConnections);
                return newSoFrictionCone;
}


SbBool SoFrictionCone::setUpConnections(SbBool onOff, SbBool doItAlways)
{
                if (!doItAlways && connectionsSetUp == onOff)
                                return onOff;
                if (onOff)
                {
                                SoBaseKit::setUpConnections(onOff, doItAlways);
                                // update before attach
                                SoFrictionCone::UpdateParametersCB(this, NULL);
                                // attach field to sensor
        if (&updateParametersTrigger != updateParametersSensor.getAttachedField())
            updateParametersSensor.attach(&updateParametersTrigger);
                }
                else
                {
        if (NULL != updateParametersSensor.getAttachedField())
            updateParametersSensor.detach();
                                SoBaseKit::setUpConnections(onOff, doItAlways);
                }

                connectionsSetUp = onOff;
                return !connectionsSetUp;
}


void SoFrictionCone::addToGraph(SoSeparator* root)
{
                SoSeparator* frictionConeSep = GetFrictionConeSeparatorFromGraph(root);
                if (NULL == frictionConeSep)
                                return;
                frictionConeSep->addChild(this);
}


void SoFrictionCone::RemoveAllFrictionConesFromGraph(SoSeparator* root)
{
                SoSeparator* frictionConeSep = GetFrictionConeSeparatorFromGraph(root);
                if (NULL == frictionConeSep)
                                return;
                frictionConeSep->removeAllChildren();
}


SoSeparator* SoFrictionCone::GetFrictionConeSeparatorFromGraph(SoSeparator* root)
{
                if (NULL == root)
                                return NULL;
                SoSeparator* frictionConeNode = static_cast<SoSeparator*> (root->getByName(SoFrictionCone::FrictionConeSeparatorName.c_str()));
                if (NULL == frictionConeNode)
                {
                                frictionConeNode = new SoSeparator;
                                frictionConeNode->setName(SoFrictionCone::FrictionConeSeparatorName.c_str());

                                dynamic_cast<SoSeparator*> (root)->addChild(frictionConeNode);
                }
                return frictionConeNode;
}


void SoFrictionCone::UpdateParametersCB(void* data, SoSensor*)
{
                SoFrictionCone* currentCone = static_cast<SoFrictionCone*> (data);
                if (NULL == currentCone)
                                return;
                SoCone* visualisationCone = dynamic_cast<SoCone*> (currentCone->getPart("visualisation", TRUE));
                if (NULL != visualisationCone)
                {
                                visualisationCone->height.setValue(currentCone->height.getValue() * currentCone->scaling.getValue());
                                visualisationCone->bottomRadius.setValue(currentCone->radius.getValue() * currentCone->scaling.getValue());
                }

                SoMaterial* coneMaterial = dynamic_cast<SoMaterial*> (currentCone->getPart("material", TRUE));
                if (NULL != coneMaterial)
                {
                                float coneTransparency = currentCone->transparency.getValue();
                                if (coneTransparency < 0) coneTransparency = 0;
                                else if (coneTransparency > 1) coneTransparency = 1;

                                currentCone->transparency.setValue(coneTransparency);
                                coneMaterial->diffuseColor.setValue(currentCone->color.getValue());
                                coneMaterial->transparency.setValue(currentCone->transparency.getValue());
                }

                SoTransform* alignment = dynamic_cast<SoTransform*> (currentCone->getPart("offsetTransform", TRUE));
                if (NULL != alignment)
                {
                                // The SoCone has it's height aligned with the Y-Axis
                                // also the visualisationCone is used for the offset computation
                                // as its values have already been scaled
                                SbVec3f offset( 0.0f, -(visualisationCone->height.getValue() / 2.0f), 0.0f);
                                alignment->translation.setValue(offset);
                }

                SoTransform* coneTransform = dynamic_cast<SoTransform*> (currentCone->getPart("transform", TRUE));
                if (NULL != coneTransform)
                {
                                // Standard orientation is along Y-Axis
                                // Therefore calculate rotation between Y-Axis and contactNormal
                                SbRotation rotation(SbVec3f(0.0f, 1.0f, 0.0f), currentCone->contactNormal.getValue());
                                SbMatrix alignmentMatrix;
                                alignmentMatrix.setTransform(currentCone->contactPoint.getValue(), rotation, SbVec3f(1, 1, 1));
                                coneTransform->setMatrix(alignmentMatrix);
                }
}

---