source/SoPhysicsSphere.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2004, University of Braunschweig (for members see AUTHORS 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/SoPhysicsSphere.h"
#include "../include/IPSA/SoCollisionShapeSphere.h"

#include <Inventor/nodes/SoSphere.h>

SO_KIT_SOURCE(SoPhysicsSphere);


void SoPhysicsSphere::initClass()
{
                SO_KIT_INIT_CLASS(SoPhysicsSphere, SoPhysics, "Physics");
}


SoPhysicsSphere::SoPhysicsSphere(const SbString& nodeName /*=""*/)
: SoPhysics(nodeName)
{
                SO_KIT_CONSTRUCTOR(SoPhysicsSphere);
                isBuiltIn = TRUE;

                SO_KIT_ADD_FIELD(radius, (1.0f));

                SO_KIT_CHANGE_ENTRY_TYPE(visualisationShape, SoNode, SoSphere);
                SO_KIT_CHANGE_ENTRY_TYPE(collisionShape, SoCollisionShape, SoCollisionShapeSphere);

                SO_KIT_CHANGE_NULL_BY_DEFAULT(visualisationShape, FALSE);
                SO_KIT_CHANGE_NULL_BY_DEFAULT(collisionShape, FALSE);

                SO_KIT_INIT_INSTANCE();

    updateDependentObjectsTrigger.appendConnection(&radius);
}


dMass SoPhysicsSphere::getInitialMass() {
                float r = this->radius.getValue();
                SbVec3f scaling = this->scale.getValue();

                float x = scaling[0] * r;
                float y = scaling[1] * r;
                float z = scaling[2] * r;

                inertia.enableNotify(false);
                float m = this->mass.getValue();
                float a = 0.2f * m * ((y*y) + (z*z));
                float b = 0.2f * m * ((x*x) + (z*z));
                float c = 0.2f * m * ((y*y) + (x*x));

                this->inertia.set1Value(0,a,0,0);
                this->inertia.set1Value(1,0,b,0);
                this->inertia.set1Value(2,0,0,c);
                inertia.enableNotify(true);
                SbVec3f i0 = this->inertia[0];
                SbVec3f i1 = this->inertia[1];
                SbVec3f i2 = this->inertia[2];

                dMass mass;
                dMassSetParameters(&mass, m, 0,0,0, i0[0],i1[1],i2[2], i0[1],i0[2],i1[2]);

                return mass;
}


void SoPhysicsSphere::updateDependentObjects()
{
                const float RADIUS_VALUE = radius.getValue();

                // the dynamic_cast returns a NULL pointer if the cast fails
                SoSphere* visShape = dynamic_cast<SoSphere*> (this->getPart("visualisationShape", FALSE));
                if (NULL != visShape)
                {
                                visShape->radius.setValue(RADIUS_VALUE);
                }

                if (FALSE == AUTO_UPDATE_COLLISION_SHAPE.getValue())
                                return;

                // the dynamic_cast returns a NULL pointer if the cast fails
                SoCollisionShapeSphere* cShape = dynamic_cast<SoCollisionShapeSphere*> (this->getPart("collisionShape", FALSE));
                if (NULL != cShape)
                {
                                cShape->radius.setValue(RADIUS_VALUE);
                }
}

---