diff options
author | Norman Lin <nlin@nlin.net> | 2002-10-18 19:46:57 +0400 |
---|---|---|
committer | Norman Lin <nlin@nlin.net> | 2002-10-18 19:46:57 +0400 |
commit | b7dadcfefd24b44283fc96207d7352732eb3dae1 (patch) | |
tree | 96c5e67b287bdaf25b280c7e9ee4d40db45c453f /source/gameengine/Ketsji | |
parent | bdad961ce365f6a57f12832b5ba763525ac164fb (diff) |
first checkin of ode blender engine files
Diffstat (limited to 'source/gameengine/Ketsji')
-rw-r--r-- | source/gameengine/Ketsji/KX_OdePhysicsController.cpp | 236 | ||||
-rw-r--r-- | source/gameengine/Ketsji/KX_OdePhysicsController.h | 100 |
2 files changed, 336 insertions, 0 deletions
diff --git a/source/gameengine/Ketsji/KX_OdePhysicsController.cpp b/source/gameengine/Ketsji/KX_OdePhysicsController.cpp new file mode 100644 index 00000000000..ece08975f4f --- /dev/null +++ b/source/gameengine/Ketsji/KX_OdePhysicsController.cpp @@ -0,0 +1,236 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * The contents of this file may be used under the terms of either the GNU + * General Public License Version 2 or later (the "GPL", see + * http://www.gnu.org/licenses/gpl.html ), or the Blender License 1.0 or + * later (the "BL", see http://www.blender.org/BL/ ) which has to be + * bought from the Blender Foundation to become active, in which case the + * above mentioned GPL option does not apply. + * + * The Original Code is Copyright (C) 2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +#include "KX_OdePhysicsController.h" +#include "KX_GameObject.h" +#include "KX_MotionState.h" + + +KX_OdePhysicsController::KX_OdePhysicsController( + bool dyna, + bool fullRigidBody, + bool phantom, + class PHY_IMotionState* motionstate, + struct dxSpace* space, + struct dxWorld* world, + float mass, + float friction, + float restitution, + bool implicitsphere, + float center[3], + float extends[3], + float radius + ) +: KX_IPhysicsController(dyna,(PHY_IPhysicsController*)this), +ODEPhysicsController( +dyna,fullRigidBody,phantom,motionstate, +space,world,mass,friction,restitution, +implicitsphere,center,extends,radius) +{ +}; + + +bool KX_OdePhysicsController::Update(double time) +{ + return SynchronizeMotionStates(time); +} + +void KX_OdePhysicsController::SetObject (SG_IObject* object) +{ + SG_Controller::SetObject(object); + + // cheating here... + KX_GameObject* gameobj = (KX_GameObject*) object->GetSGClientObject(); + gameobj->m_pPhysicsController1 = this; + +} + + + +void KX_OdePhysicsController::applyImpulse(const MT_Point3& attach, const MT_Vector3& impulse) +{ + ODEPhysicsController::applyImpulse(attach[0],attach[1],attach[2],impulse[0],impulse[1],impulse[2]); +} + + + +void KX_OdePhysicsController::RelativeTranslate(const MT_Vector3& dloc,bool local) +{ + ODEPhysicsController::RelativeTranslate(dloc[0],dloc[1],dloc[2],local); + +} +void KX_OdePhysicsController::RelativeRotate(const MT_Matrix3x3& drot,bool local) +{ + double oldmat[12]; + drot.getValue(oldmat); + float newmat[9]; + float *m = &newmat[0]; + double *orgm = &oldmat[0]; + + *m++ = *orgm++;*m++ = *orgm++;*m++ = *orgm++;orgm++; + *m++ = *orgm++;*m++ = *orgm++;*m++ = *orgm++;orgm++; + *m++ = *orgm++;*m++ = *orgm++;*m++ = *orgm++;orgm++; + + ODEPhysicsController::RelativeRotate(newmat,local); + +} + +void KX_OdePhysicsController::ApplyTorque(const MT_Vector3& torque,bool local) +{ + ODEPhysicsController::ApplyTorque(torque[0],torque[1],torque[2],local); + +} +void KX_OdePhysicsController::ApplyForce(const MT_Vector3& force,bool local) +{ + ODEPhysicsController::ApplyForce(force[0],force[1],force[2],local); + +} +MT_Vector3 KX_OdePhysicsController::GetLinearVelocity() +{ + return MT_Vector3(0,0,0); +} + +MT_Vector3 KX_OdePhysicsController::GetVelocity(const MT_Point3& pos) +{ + return MT_Vector3(0,0,0); +} + +void KX_OdePhysicsController::SetAngularVelocity(const MT_Vector3& ang_vel,bool local) +{ + +} +void KX_OdePhysicsController::SetLinearVelocity(const MT_Vector3& lin_vel,bool local) +{ + ODEPhysicsController::SetLinearVelocity(lin_vel[0],lin_vel[1],lin_vel[2],local); +} + +void KX_OdePhysicsController::setOrientation(const MT_Quaternion& orn) +{ + ODEPhysicsController::setOrientation(orn[0],orn[1],orn[2],orn[3]); +} + +void KX_OdePhysicsController::getOrientation(MT_Quaternion& orn) +{ + float florn[4]; + florn[0]=orn[0]; + florn[1]=orn[1]; + florn[2]=orn[2]; + florn[3]=orn[3]; + ODEPhysicsController::getOrientation(florn[0],florn[1],florn[2],florn[3]); + orn[0] = florn[0]; + orn[1] = florn[1]; + orn[2] = florn[2]; + orn[3] = florn[3]; + + +} + +void KX_OdePhysicsController::setPosition(const MT_Point3& pos) +{ + ODEPhysicsController::setPosition(pos[0],pos[1],pos[2]); +} + +void KX_OdePhysicsController::setScaling(const MT_Vector3& scaling) +{ +} + +MT_Scalar KX_OdePhysicsController::GetMass() +{ + return ODEPhysicsController::getMass(); +} + +MT_Vector3 KX_OdePhysicsController::getReactionForce() +{ + return MT_Vector3(0,0,0); +} +void KX_OdePhysicsController::setRigidBody(bool rigid) +{ + +} + +void KX_OdePhysicsController::SuspendDynamics() +{ + ODEPhysicsController::SuspendDynamics(); +} +void KX_OdePhysicsController::RestoreDynamics() +{ + ODEPhysicsController::RestoreDynamics(); +} + + +SG_Controller* KX_OdePhysicsController::GetReplica(class SG_Node* destnode) +{ + PHY_IMotionState* motionstate = new KX_MotionState(destnode); + KX_OdePhysicsController* copyctrl = new KX_OdePhysicsController(*this); + + // nlin: copied from KX_SumoPhysicsController.cpp. Not 100% sure what this does.... + // furthermore, the parentctrl is not used in ODEPhysicsController::PostProcessReplica, but + // maybe it can/should be used in the future... + + // begin copy block ------------------------------------------------------------------ + + //parentcontroller is here be able to avoid collisions between parent/child + + PHY_IPhysicsController* parentctrl = NULL; + + if (destnode != destnode->GetRootSGParent()) + { + KX_GameObject* clientgameobj = (KX_GameObject*) destnode->GetRootSGParent()->GetSGClientObject(); + if (clientgameobj) + { + parentctrl = (KX_OdePhysicsController*)clientgameobj->GetPhysicsController(); + } else + { + // it could be a false node, try the children + NodeList::const_iterator childit; + for ( + childit = destnode->GetSGChildren().begin(); + childit!= destnode->GetSGChildren().end(); + ++childit + ) { + KX_GameObject* clientgameobj = static_cast<KX_GameObject*>( (*childit)->GetSGClientObject()); + if (clientgameobj) + { + parentctrl = (KX_OdePhysicsController*)clientgameobj->GetPhysicsController(); + } + } + } + } + // end copy block ------------------------------------------------------------------ + + copyctrl->PostProcessReplica(motionstate, this); + + return copyctrl; + +} + + + +void KX_OdePhysicsController::SetSumoTransform(bool nondynaonly) +{ + +} + // todo: remove next line ! +void KX_OdePhysicsController::SetSimulatedTime(double time) +{ + +} + diff --git a/source/gameengine/Ketsji/KX_OdePhysicsController.h b/source/gameengine/Ketsji/KX_OdePhysicsController.h new file mode 100644 index 00000000000..89141f68488 --- /dev/null +++ b/source/gameengine/Ketsji/KX_OdePhysicsController.h @@ -0,0 +1,100 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * The contents of this file may be used under the terms of either the GNU + * General Public License Version 2 or later (the "GPL", see + * http://www.gnu.org/licenses/gpl.html ), or the Blender License 1.0 or + * later (the "BL", see http://www.blender.org/BL/ ) which has to be + * bought from the Blender Foundation to become active, in which case the + * above mentioned GPL option does not apply. + * + * The Original Code is Copyright (C) 2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +#ifndef __KX_ODEPHYSICSCONTROLLER_H +#define __KX_ODEPHYSICSCONTROLLER_H + +#include "KX_IPhysicsController.h" +#include "OdePhysicsController.h" + + +/** + Physics Controller, a special kind of Scene Graph Transformation Controller. + It get's callbacks from Physics in case a transformation change took place. + Each time the scene graph get's updated, the controller get's a chance + in the 'Update' method to reflect changed. +*/ + +class KX_OdePhysicsController : public KX_IPhysicsController, public ODEPhysicsController + +{ + +public: + KX_OdePhysicsController( + bool dyna, + bool fullRigidBody, + bool phantom, + class PHY_IMotionState* motionstate, + struct dxSpace* space, + struct dxWorld* world, + float mass, + float friction, + float restitution, + bool implicitsphere, + float center[3], + float extends[3], + float radius); + + virtual ~KX_OdePhysicsController() {}; + + virtual void applyImpulse(const MT_Point3& attach, const MT_Vector3& impulse); + virtual void SetObject (SG_IObject* object); + + virtual void RelativeTranslate(const MT_Vector3& dloc,bool local); + virtual void RelativeRotate(const MT_Matrix3x3& drot,bool local); + virtual void ApplyTorque(const MT_Vector3& torque,bool local); + virtual void ApplyForce(const MT_Vector3& force,bool local); + virtual MT_Vector3 GetLinearVelocity(); + virtual MT_Vector3 GetVelocity(const MT_Point3& pos); + virtual void SetAngularVelocity(const MT_Vector3& ang_vel,bool local); + virtual void SetLinearVelocity(const MT_Vector3& lin_vel,bool local); + virtual void getOrientation(MT_Quaternion& orn); + virtual void setOrientation(const MT_Quaternion& orn); + virtual void setPosition(const MT_Point3& pos); + virtual void setScaling(const MT_Vector3& scaling); + virtual MT_Scalar GetMass(); + virtual MT_Vector3 getReactionForce(); + virtual void setRigidBody(bool rigid); + + virtual void SuspendDynamics(); + virtual void RestoreDynamics(); + + + virtual SG_Controller* GetReplica(class SG_Node* destnode); + + + virtual void SetSumoTransform(bool nondynaonly); + // todo: remove next line ! + virtual void SetSimulatedTime(double time); + + // call from scene graph to update + virtual bool Update(double time); + + void + SetOption( + int option, + int value + ){ + // intentionally empty + }; + +}; +#endif //__KX_ODEPHYSICSCONTROLLER_H |