include/IPSA/SoWorldPhysics.h

Go to the documentation of this file.

#ifndef IPSA_SOWORLDPHYSICS_H
#define IPSA_SOWORLDPHYSICS_H
/*
 * Copyright (c) 2004, University of Braunschweig (for members see AUTHORS file)
 * Copyright (c) 2007, 2008, 2009, University of Karlsruhe (for members see AUTHORS file)
 * Copyright (c) 2011, Karlsruhe Institute of Technology (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 "IPSA.h"
#include "SoCollisionShape.h"

#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/actions/SoCallbackAction.h>
#include <Inventor/sensors/SoTimerSensor.h>
#include <Inventor/sensors/SoFieldSensor.h>
#include <Inventor/fields/SoSFFloat.h>
#include <Inventor/fields/SoSFInt32.h>
#include <Inventor/fields/SoSFVec3f.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoSFTrigger.h>
#include <ode/ode.h>

#include <vector>

class IPSA_IMPORT_EXPORT SoWorldPhysics : public SoSeparator
{

SO_NODE_HEADER(SoWorldPhysics);

public:
                SoWorldPhysics(const SbString& nodeName = "", int numChildren = 5);
                // Destructor
                virtual ~SoWorldPhysics();

                static void initClasses();
                static void initClass();
                static void Init();
                static void DeInit();

                virtual SbBool setUpConnections(SbBool onOff, SbBool doItAlways = FALSE);
                virtual SbBool readInstance(SoInput* in, unsigned short flags);

                static SoCallbackAction::Response InitialiseWorldCB(void* userdata, SoCallbackAction*, const SoNode* node);
                static SoCallbackAction::Response ScheduleWorldCB(void* userdata, SoCallbackAction*, const SoNode* node);
                static SoCallbackAction::Response UnscheduleWorldCB(void* userdata, SoCallbackAction*, const SoNode* node);
                static SoCallbackAction::Response UpdateSingleWorldCB(void*, SoCallbackAction* action, const SoNode* node);
    static SoCallbackAction::Response ResetWorldCB(void* userdata, SoCallbackAction* action, const SoNode* node);

                static void NearCallback (void* data, dGeomID o1, dGeomID o2);
                static void StepOde(void* data, SoSensor*);
                static void ApplyActionToWorldPhysicNodesInGraph(SoCallbackAction::SoCallbackActionCB &cb, SoNode* root,  void* userdata=NULL);

                void initialiseWorld();
    void resetWorld();
                void setStepsize(float stepSizeInSeconds); // set stepsize for ODE in [seconds]
                float getStepsize();
                void schedule();
                void unschedule();
                bool isScheduled() {return (this->sens.isScheduled() == TRUE);}

                static bool IsNaN (double value);

                dWorldID ownworld;
                dSpaceID ownspace;

                SoSFVec3f gravity;
                SoSFFloat ERP;
                SoSFFloat CFM;
    SoSFFloat SoftERP;
                SoSFFloat SoftCFM;

                enum eContactApprox
                {
                                BOXFRICTION     = dContactApprox0,
                                PYRAMIDFRICTION = dContactApprox1_1
                };

                SoSFEnum ContactApprox;
                dJointGroupID contactgroup;

                //   enum solver
                enum eStepping
                {
                                WORLDSTEP,
                                QUICKSTEP,
                                STEPFAST1
                };
                SoSFEnum stepping;
                SoSFInt32 sf1maxiterations;

                const int MAX_BODY_CONTACTS;      // maximum number of contact points per body: 64
                const float DEFAULT_ODE_STEPSIZE; // default stepsize for ODE in [sec]: 0.004f

protected:
                SoSFTrigger updateOdeParamtersTrigger;
                SoFieldSensor updateOdeParamtersSensor;
                SbBool connectionsSetUp;

private:
                static void updateOdeParamtersCB(void* data, SoSensor*);

                SoSFFloat stepsize;
                SoTimerSensor sens;
                std::vector<dJointFeedback> iContactFeedback;

                static bool bOdeColliderInitialised;
                static bool bClassesInitialised;

    static double frictioncoeff[SoCollisionShape::NO_OF_SURFACEMATERIALS][SoCollisionShape::NO_OF_SURFACEMATERIALS];
};

#endif 

---