void PhysicsBody::adjustMass( Real32 newMass )
{
    dMass mass;
    getMassStruct(mass);
    dMassAdjust(&mass, newMass);
    setMassStruct(mass);
}
void constructWorldForTest (dReal gravity, int bodycount,
 /* body 1 pos */           dReal pos1x, dReal pos1y, dReal pos1z,
 /* body 2 pos */           dReal pos2x, dReal pos2y, dReal pos2z,
 /* body 1 rotation axis */ dReal ax1x, dReal ax1y, dReal ax1z,
 /* body 1 rotation axis */ dReal ax2x, dReal ax2y, dReal ax2z,
 /* rotation angles */      dReal a1, dReal a2)
{
  // create world
  world = dWorldCreate();
  dWorldSetERP (world,0.2);
  dWorldSetCFM (world,1e-6);
  dWorldSetGravity (world,0,0,gravity);

  dMass m;
  dMassSetBox (&m,1,SIDE,SIDE,SIDE);
  dMassAdjust (&m,MASS);

  body[0] = dBodyCreate (world);
  dBodySetMass (body[0],&m);
  dBodySetPosition (body[0], pos1x, pos1y, pos1z);
  dQuaternion q;
  dQFromAxisAndAngle (q,ax1x,ax1y,ax1z,a1);
  dBodySetQuaternion (body[0],q);

  if (bodycount==2) {
    body[1] = dBodyCreate (world);
    dBodySetMass (body[1],&m);
    dBodySetPosition (body[1], pos2x, pos2y, pos2z);
    dQFromAxisAndAngle (q,ax2x,ax2y,ax2z,a2);
    dBodySetQuaternion (body[1],q);
  }
  else body[1] = 0;
}
void PhysicsActor::postLoad(){

	dMass m;

    if (type==CUBESHAPE)
      {
	  geom = dCreateBox(space,shape.x,shape.y,shape.z);
      dMassSetBox(&m,1.0f,shape.x,shape.y,shape.z);
      }
	if (type==CAPSULESHAPE)
	  {
	  geom = dCreateCapsule(space,shape.x,shape.y);
      dMassSetCapsule(&m, shape.z, 3, shape.x, shape.y);      //the '3' means align on z-axis  and density is shape.z
	  generateCapsuleList();
	  }
	dMassAdjust(&m,mass);
	dBodySetMass(body,&m);


	dGeomSetBody(geom,body);

    //initialise position
    if (base){
        Matrix4f bGlobal= base->baseMatrix * renderer->inverseCameraMatrix;
        dBodySetPosition(body,bGlobal.data[12] + originalMatrix.data[12] + transformMatrix.data[12],bGlobal.data[13] + originalMatrix.data[13] + transformMatrix.data[13],bGlobal.data[14] + originalMatrix.data[14] + transformMatrix.data[14]);
    }else{
        dBodySetPosition(body,originalMatrix.data[12] + transformMatrix.data[12],originalMatrix.data[13] + transformMatrix.data[13],originalMatrix.data[14] + transformMatrix.data[14]);
    }

   dBodySetDamping(body, linearDamp, angleDamp);

   bInit=true;

}
Esempio n. 4
0
void	CPHActivationShape::Create(const Fvector start_pos,const Fvector start_size,IPhysicsShellHolder* ref_obj,EType _type/*=etBox*/,u16	flags)
{
	VERIFY(ref_obj);
	R_ASSERT(_valid( start_pos ) );
	R_ASSERT( _valid( start_size ) );

	m_body			=	dBodyCreate	(0)												;
	dMass m;
	dMassSetSphere(&m,1.f,100000.f);
	dMassAdjust(&m,1.f);
	dBodySetMass(m_body,&m);
	switch(_type)
	{
	case etBox:
	m_geom			=	dCreateBox	(0,start_size.x,start_size.y,start_size.z)		;
	break;

	case etSphere:
	m_geom			=	dCreateSphere	(0,start_size.x);
	break;
	};

	dGeomCreateUserData				(m_geom)										;
	dGeomUserDataSetObjectContactCallback(m_geom,ActivateTestDepthCallback)			;
	dGeomUserDataSetPhysicsRefObject(m_geom,ref_obj)								;
	dGeomSetBody					(m_geom,m_body)									;
	dBodySetPosition				(m_body,start_pos.x,start_pos.y,start_pos.z)	;
	Island()		.AddBody		(m_body)										;
	dBodyEnable						(m_body)										;
	m_safe_state					.create(m_body)									;
	spatial_register				()												;
	m_flags.set(flags,TRUE);
}
Esempio n. 5
0
void dMassSetTrimeshTotal( dMass *m, dReal total_mass, dGeomID g)
{
  dAASSERT( m );
  dUASSERT( g && g->type == dTriMeshClass, "argument not a trimesh" );
  dMassSetTrimesh( m, 1.0, g );
  dMassAdjust( m, total_mass );
}
void Robots::construirChassi(dWorldID world)
{
    for (int i=0; i < 2; i++)
    {
        // Cria objeto e geometria
        this->body[i] = dBodyCreate(world);
        this->box[i] = dCreateBox(0,LENGTH/(1+i),WIDTH,HEIGHT);

        // Define a posição do objeto
        dBodySetPosition(this->body[i],this->pegarX(),this->pegarY(),STARTZ+HEIGHT/2-HEIGHT*i);

		// Se o robô for do segundo time, deve ser rotacionado em 180 graus
        if ((this->id == 3) || (this->id == 4) || (this->id == 5))
        {
			dQuaternion q;
			dQFromAxisAndAngle(q,0,0,1,M_PI);
			dBodySetQuaternion(this->body[i],q);
		}

        // Define a massa do objeto
        dMass m;
        dMassSetBox(&m,1,LENGTH/(1+i),WIDTH,HEIGHT);	// O segundo bloco é mais curto
        dMassAdjust(&m,CMASS*(1+i*2));					// O segundo bloco é mais pesado
        dBodySetMass(this->body[i],&m);
                
        // Associa o objeto à sua geometria
        dGeomSetBody(this->box[i],this->body[i]);
    }
		
    // O chassis é composto por dois blocos que são fixos entre si
    dJointID fixed = dJointCreateFixed(world,0);
    dJointAttach(fixed,this->body[1],this->body[0]);
    dJointSetFixed(fixed); 
}
Esempio n. 7
0
void Cylinder::computeMassProperties(dMass& m)
{
  if(capped)
    dMassSetCapsule(&m, 1, 3, dReal(height), dReal(height));
  else
    dMassSetCylinder(&m, 1, 3, dReal(height), dReal(height));
  dMassAdjust(&m, dReal(mass));
}
Esempio n. 8
0
void PCylinder::setMass(float mass)
{
  m_mass = mass;
  dMass m;
  dMassSetCylinder (&m,1,1,m_radius,m_length);
  dMassAdjust (&m,m_mass);
  dBodySetMass (body,&m);
}
Esempio n. 9
0
void CODEGeom::get_mass(dMass& m,const Fvector& ref_point, float density)
{
	get_mass(m);
	dMassAdjust(&m,density*volume());
	Fvector l;
	l.sub(local_center(),ref_point);
	dMassTranslate(&m,l.x,l.y,l.z);
}
Esempio n. 10
0
void VStateSphereMass::Apply()
{
	VState::Parent pParent = GetParent();

	dMassSetSphere (&m_Mass, GetDensity(), m_fRadius);
	dMassAdjust (&m_Mass, GetMass());
	dBodySetMass (pParent->GetBodyID(),&m_Mass);
}
Esempio n. 11
0
 void Sphere::setMass(double mass, bool density){
   if(body){
     dMass m;
     dMassSetSphere(&m, mass, osgsphere->getRadius());
     if(!density)
       dMassAdjust (&m, mass);
     dBodySetMass (body,&m); //assign the mass to the body
   }
 }
Esempio n. 12
0
 void Capsule::setMass(double mass, bool density){
   if(mass){
     dMass m;
     dMassSetCapsule(&m, mass, 3 , osgcapsule->getRadius(), osgcapsule->getHeight());
     if(!density)
       dMassAdjust (&m, mass);
     dBodySetMass (body,&m); //assign the mass to the body
   }
 }
SphereGeom::SphereGeom(Body* in_pBody, Space* in_pSpace, double radius) 
	: Geom(in_pSpace)
{
	m_pBody = in_pBody;
	dMassSetSphere(&m_mass,1,radius);
	dMassAdjust(&m_mass,1);
	m_id = dCreateSphere(m_pSpace->id(),radius);
	finishGeom();
}
Esempio n. 14
0
 void Plane::setMass(double mass, bool density){
   if(body){
     dMass m;
     dMassSetBox(&m,mass,1000,1000,0.01); // fake the mass of the plane with a thin box
     if(!density)
       dMassAdjust (&m, mass);
     dBodySetMass (body,&m); //assign the mass to the body
   }
 }
Esempio n. 15
0
 void Cylinder::setMass(double mass, bool density){
   if(body){
     dMass m;
     dMassSetCylinder(&m, mass, 3 , osgcylinder->getRadius(), osgcylinder->getHeight());
     if(!density)
       dMassAdjust (&m, mass);
     dBodySetMass (body,&m); //assign the mass to the body
   }
 }
//===========================================================================
void cODEGenericBody::createDynamicBox(const double a_lengthX,
									   const double a_lengthY,
									   const double a_lengthZ,
                                       bool a_staticObject,
									   const cVector3d& a_offsetPos,
									   const cMatrix3d& a_offsetRot)
{
    // create ode dynamic body if object is non static
    if (!a_staticObject)
    {
        m_ode_body = dBodyCreate(m_ODEWorld->m_ode_world);

	    // store pointer to current object
	    dBodySetData (m_ode_body, this);
    }
    m_static = a_staticObject;

    // build box
    m_ode_geom = dCreateBox(m_ODEWorld->m_ode_space, a_lengthX, a_lengthY, a_lengthZ);

	// adjust position offset
	dGeomSetPosition (m_ode_geom, a_offsetPos.x, a_offsetPos.y, a_offsetPos.z);

	// adjust orientation offset
	dMatrix3 R;
	R[0]  = a_offsetRot.m[0][0];
	R[1]  = a_offsetRot.m[0][1];
	R[2]  = a_offsetRot.m[0][2];
	R[4]  = a_offsetRot.m[1][0];
	R[5]  = a_offsetRot.m[1][1];
	R[6]  = a_offsetRot.m[1][2];
	R[8]  = a_offsetRot.m[2][0];
	R[9]  = a_offsetRot.m[2][1];
	R[10] = a_offsetRot.m[2][2];
	dGeomSetRotation (m_ode_geom, R);

    // set inertia properties
    if (!m_static)
    {
        dMassSetBox(&m_ode_mass, 1.0, a_lengthX, a_lengthY, a_lengthZ);
	    dMassAdjust(&m_ode_mass, m_mass);
	    dBodySetMass(m_ode_body,&m_ode_mass);

        // attach body and geometry together
        dGeomSetBody(m_ode_geom, m_ode_body);
    }

    // store dynamic model type
    m_typeDynamicCollisionModel = ODE_MODEL_BOX;

    // store dynamic model parameters
    m_paramDynColModel0 = a_lengthX;
    m_paramDynColModel1 = a_lengthY;
    m_paramDynColModel2 = a_lengthZ;
    m_posOffsetDynColModel = a_offsetPos;
    m_rotOffsetDynColModel = a_offsetRot;
}
Esempio n. 17
0
void SBoxParts::set(dWorldID w, dSpaceID space)
{
	Size &sz = m_cmpnt.size();
	/*
	const dReal hx = sz.x();
	const dReal hy = sz.y();
	const dReal hz = sz.z();
	*/
	dReal hx = sz.x();
	dReal hy = sz.y();
	dReal hz = sz.z();

	// konao
	DUMP(("[SBoxParts::set] ODE geom created (hx, hy, hz)=(%f, %f, %f) [%s:%d]\n", hx, hy, hz, __FILE__, __LINE__));

	if (hz == 0) hz = 0.001;
	if (hy == 0) hy = 0.001;
	if (hx == 0) hx = 0.001;

	dGeomID geom = dCreateBox(0, hx, hy, hz);
	m_odeobj = ODEObjectContainer::getInstance()->createODEObj
	(
		w,
		geom,
		0.9,
		0.01,
		0.5,
		0.5,
		0.8,
		0.001,
		0.0
	);

	dBodyID body = m_odeobj->body();
	dMass m;
	dMassSetZero(&m);

	// x-axis and z-axis is swapped between ODE/SIGVerse
	dMassSetBox(&m, DENSITY, hz, hy, hx); //TODO: mass of cube should be configurable
	dMassAdjust(&m, m_mass);
	dBodySetMass(body, &m);

	// Gap between ODE shape and body
	dGeomSetOffsetPosition(geom, m_posx, m_posy, m_posz);

	// Initial orientation
	dReal offq[4] = {m_inirot.qw(), m_inirot.qx(), m_inirot.qy(), m_inirot.qz()};
	dGeomSetOffsetQuaternion(geom, offq);
	//dMassAdjust(&m, 1.0);

	m_rot.setQuaternion(1.0, 0.0, 0.0, 0.0);

	dSpaceAdd(space, geom);

	dBodySetData(body, this);
}
Esempio n. 18
0
void CPHCapture::CreateBody()
{
    m_body= dBodyCreate(0);
    m_island.AddBody(m_body);
    dMass m;
    dMassSetSphere(&m,1.f,1000000.f);
    dMassAdjust(&m,100000.f);
    dBodySetMass(m_body,&m);
    dBodySetGravityMode(m_body,0);
}
Esempio n. 19
0
void ode::newLine(float xp, float yp)
{
		b = dBodyCreate (world);
		dBodySetPosition (b,xp,yp,2);
		//dMassSetSphere (&m,1,RADIUS);
		dMassAdjust (&m, 1);
		dBodySetMass (b,&m);
		lineStrips[lines] = dCreateSphere (space,RADIUS);
		dGeomSetBody (lineStrips[lines++],b);		
}
Esempio n. 20
0
 void Mesh::setMass(double mass, bool density){
   if(body){
     // we should use the bouding box here
     dMass m;
     dMassSetSphere(&m, mass, osgmesh->getRadius()); // we use a sphere
     if(!density)
       dMassAdjust (&m, mass);
     dBodySetMass (body,&m); //assign the mass to the body
   }
 }
Esempio n. 21
0
 void Box::setMass(double mass, bool density){
   if(body){
     dMass m;
     osg::Vec3 dim = osgbox->getDim();
     dMassSetBox(&m, mass, dim.x() , dim.y() , dim.z());
     if(!density)
       dMassAdjust (&m, mass);
     dBodySetMass (body,&m); //assign the mass to the body
   }
 }
Esempio n. 22
0
void LinkBoxDesign::create(dWorldID world, dSpaceID space, dGeomID * geom,
			   dBodyID * body)
{
	body[0] = dBodyCreate(world);
	geom[0] = dCreateBox(space, sides[XX], sides[YY], sides[ZZ]);
	dGeomSetBody(geom[0], body[0]);
	dMass m;
	dMassSetBox(&m, 1, sides[XX], sides[YY], sides[ZZ]);
	dMassAdjust(&m, LINK_MASS);
	dBodySetMass(body[0], &m);
}
Esempio n. 23
0
void SParts::setMass(double mass)
{
	m_mass = mass;
	if(m_odeobj != NULL) {
		dMass m;
		dBodyGetMass(m_odeobj->body(), &m);
		dMassAdjust(&m, m_mass);
		dBodyID body = m_odeobj->body();
		dBodySetMass(body, &m);
	}
}
Esempio n. 24
0
void FixBody(dBodyID body,float ext_param,float mass_param)
{
	dMass m;
	dMassSetSphere(&m,1.f,ext_param);
	dMassAdjust(&m,mass_param);
	dBodySetMass(body,&m);
	dBodySetGravityMode(body,0);
	dBodySetLinearVel(body,0,0,0);
	dBodySetAngularVel(body,0,0,0);
	dBodySetForce(body,0,0,0);
	dBodySetTorque(body,0,0,0);
}
Esempio n. 25
0
int main (int argc, char **argv)
{
  int i;
  dReal k;
  dMass m;

  /* setup pointers to drawstuff callback functions */
  dsFunctions fn;
  fn.version = DS_VERSION;
  fn.start = &start;
  fn.step = &simLoop;
  fn.command = 0;
  fn.stop = 0;
  fn.path_to_textures = "../../drawstuff/textures";
  if(argc==2)
    {
        fn.path_to_textures = argv[1];
    }

  /* create world */
  dInitODE();
  world = dWorldCreate();
  space = dHashSpaceCreate (0);
  contactgroup = dJointGroupCreate (1000000);
  dWorldSetGravity (world,0,0,-0.5);
  dCreatePlane (space,0,0,1,0);

  for (i=0; i<NUM; i++) {
    body[i] = dBodyCreate (world);
    k = i*SIDE;
    dBodySetPosition (body[i],k,k,k+0.4);
    dMassSetBox (&m,1,SIDE,SIDE,SIDE);
    dMassAdjust (&m,MASS);
    dBodySetMass (body[i],&m);
    sphere[i] = dCreateSphere (space,RADIUS);
    dGeomSetBody (sphere[i],body[i]);
  }
  for (i=0; i<(NUM-1); i++) {
    joint[i] = dJointCreateBall (world,0);
    dJointAttach (joint[i],body[i],body[i+1]);
    k = (i+0.5)*SIDE;
    dJointSetBallAnchor (joint[i],k,k,k+0.4);
  }

  /* run simulation */
  dsSimulationLoop (argc,argv,352,288,&fn);

  dJointGroupDestroy (contactgroup);
  dSpaceDestroy (space);
  dWorldDestroy (world);
  dCloseODE();
  return 0;
}
Esempio n. 26
0
void ode::newBall(int xp, int yp)
{ 
		dReal z=1,y=1,x=1;
	
		b = dBodyCreate (world);
		dBodySetPosition (b,xp,yp,2);
		dMassSetSphere (&m,1,RADIUS);
		dMassAdjust (&m, 1);
		dBodySetMass (b,&m);
		sphere[spheres] = dCreateSphere (space,RADIUS);
		dGeomSetBody (sphere[spheres++],b);		
}
//===========================================================================
void cODEGenericBody::setMass(double a_mass)
{
    // check if ODE body defined
    if (m_ode_body == NULL) { return; }

    // store value
    m_mass = a_mass;

    // adjust mass
    dMassAdjust(&m_ode_mass, a_mass);
	dBodySetMass(m_ode_body,&m_ode_mass);
}
//===========================================================================
void cODEGenericBody::createDynamicBoundingBox(bool a_staticObject)
{
	// check if body image exists
	if (m_imageModel == NULL) { return; }

    // create ode dynamic body if object is non static
    if (!a_staticObject)
    {
        m_ode_body = dBodyCreate(m_ODEWorld->m_ode_world);

	    // store pointer to current object
	    dBodySetData (m_ode_body, this);
    }
    m_static = a_staticObject;

    // computing bounding box of geometry representation
    m_imageModel->computeBoundaryBox(true);

    // get size and center of box
    cVector3d center = m_imageModel->getBoundaryCenter();

    // compute dimensions
    cVector3d size = m_imageModel->getBoundaryMax() -
                     m_imageModel->getBoundaryMin();

    // build box
    m_ode_geom = dCreateBox(m_ODEWorld->m_ode_space, size.x, size.y , size.z);

    // offset box
    dGeomSetPosition (m_ode_geom, center.x, center.y, center.z);

    if (!m_static)
    {
        // set inertia properties
        dMassSetBox(&m_ode_mass, 1.0, size.x, size.y, size.z);
	    dMassAdjust(&m_ode_mass, m_mass);
	    dBodySetMass(m_ode_body,&m_ode_mass);

        // attach body and geometry together
        dGeomSetBody(m_ode_geom, m_ode_body);
    }

    // store dynamic model type
    m_typeDynamicCollisionModel = ODE_MODEL_BOX;

    // store dynamic model parameters
    m_paramDynColModel0 = size.x;
    m_paramDynColModel1 = size.y;
    m_paramDynColModel2 = size.z;
    //m_posOffsetDynColModel;
    //m_rotOffsetDynColModel;
}
Esempio n. 29
0
WheelItem::WheelItem(dWorldID world,dSpaceID space,dQuaternion q,dReal radius,dReal mass)
{
  body = dBodyCreate(world);
  geom = dCreateSphere(space,radius);
  dBodySetQuaternion(body,q);

  dMass m;
  dMassSetSphere(&m,1,radius);
  dMassAdjust(&m,mass);
  dBodySetMass(body,&m);

  dGeomSetBody(geom,body);	
}
Esempio n. 30
0
void LaserBeam::embody(dBodyID myBodySelf)
{
    dMass m;

    float myMass = 1.0f;

    dBodySetPosition(myBodySelf, pos[0], pos[1], pos[2]);
    dMassSetBox(&m, 1,Gunshot::width, Gunshot::height, Gunshot::length);
    dMassAdjust(&m, myMass*1.0f);
    dBodySetMass(myBodySelf,&m);

    me = myBodySelf;

}