ODEItem v0.10

dBodySetMass (mBodyID,&mMass);
	dBodySetLinearVel(mBodyID,mVelocity.x,mVelocity.y,mVelocity.z);
	dBodySetPosition (mBodyID, mDelta.pos.x,
							 mDelta.pos.y,
							 mDelta.pos.z);

mIsEnabled = true;

U32 ODEItem::packUpdate(NetConnection * con, U32 mask, BitStream * stream)
{
	U32 retMask = Parent::packUpdate(con, mask, stream);

    if(stream->writeFlag(mask & (PositionMask | RotationMask))){
		/*if(*/stream->writeFlag(dBodyIsEnabled(mBodyID));/*){*/
		   stream->writeAffineTransform(getTransform());
//		   const dReal *angVel = dBodyGetAngularVel(mBodyID);
//		   stream->writeCompressedPoint(Point3F(angVel[0],angVel[1],angVel[2]));
		   const dReal *vel = dBodyGetLinearVel(mBodyID);
		   stream->writeCompressedPoint(Point3F(vel[0],vel[1],vel[2]));
		/*}*/
	}

	if (stream->writeFlag(mask & PropertyUpdate))
	{
		// Write Object Properties.
		//stream->write(mMass);
		stream->writeCompressedPoint(mObjScale);
        if(stream->writeFlag(mOverride)) {
               stream->write(mFriction1);
               stream->write(mFriction2);
               stream->write(mBounceVel);
               stream->write(mBounce);
        }
	}

	// Were done ...
	return(retMask);
}

void ODEItem::unpackUpdate(NetConnection * con, BitStream * stream)
{
	// Unpack Parent.
   	Parent::unpackUpdate(con, stream);

	//mBreak = stream->readFlag();
/*  if(mBreak && isClientObject()){
    int i =0;
	i++;
  }
*/	if(stream->readFlag()){ //DynamicObjectupdate
		mIsEnabled = stream->readFlag();
			//mIsEnabled = true;
		//if(mIsEnabled){ //is it enabled?
			
			if(mBodyID)
    			dBodyEnable(mBodyID);

			mPredictionCount = 30; //sMaxPredictionTicks;
			QuatF rotation = QuatF(getTransform());
			mDelta.warpRot[0] = rotation;
			F32 speed = mVelocity.len();

			MatrixF		ObjectMatrix;
			stream->readAffineTransform(&ObjectMatrix);
			//stream->readCompressedPoint(&mAngVel);
			stream->readCompressedPoint(&mVelocity);
			rotation = QuatF(ObjectMatrix);

	///RIPPED FROM VEHICLE.CS///////////////
		  if (isProperlyAdded()) {
			 // Determin number of ticks to warp based on the average
			 // of the client and server velocities.
			 Point3F cp = mDelta.pos + mDelta.posVec * mDelta.dt;
			 mDelta.warpOffset = ObjectMatrix.getPosition() - cp;

			 // Calc the distance covered in one tick as the average of
			 // the old speed and the new speed from the server.
			 F32 dt,as = (speed + mVelocity.len()) * 0.5 * TickSec;

			 // Cal how many ticks it will take to cover the warp offset.
			 // If it's less than what's left in the current tick, we'll just
			 // warp in the remaining time.
			 if (!as || (dt = mDelta.warpOffset.len() / as) > 3)//sMaxWarpTicks)
				dt = mDelta.dt + 3;//sMaxWarpTicks;
			 else
				dt = (dt <= mDelta.dt)? mDelta.dt : mCeil(dt - mDelta.dt) + mDelta.dt;

			 // Adjust current frame interpolation
			 if (mDelta.dt) {
				mDelta.pos = cp + (mDelta.warpOffset * (mDelta.dt / dt));
				mDelta.posVec = (cp - mDelta.pos) / mDelta.dt;
				QuatF cr;
				cr.interpolate(mDelta.rot[1],mDelta.rot[0],mDelta.dt);
				mDelta.rot[1].interpolate(cr,rotation,mDelta.dt / dt);
				mDelta.rot[0].extrapolate(mDelta.rot[1],cr,mDelta.dt);
				//mDelta.rot[0] = mDelta.rot[1];
			 }

			 // Calculated multi-tick warp
			 mDelta.warpCount = 0;
			 mDelta.warpTicks = (S32)(mFloor(dt));
			 if (mDelta.warpTicks) {
				mDelta.warpOffset = ObjectMatrix.getPosition() - mDelta.pos;
				mDelta.warpOffset /= mDelta.warpTicks;
				mDelta.warpRot[0] = mDelta.rot[1];
				mDelta.warpRot[1] = rotation;
			 }
		  }
		  else {
			  // Set the object to the server position
			 mDelta.dt  = 0;
			 mDelta.pos = ObjectMatrix.getPosition();
			 mDelta.posVec.set(0,0,0);
			 mDelta.rot[1] = mDelta.rot[0] = rotation;
			 mDelta.warpCount = mDelta.warpTicks = 0;
             Parent::setTransform(ObjectMatrix);
			}
		}else if(mBodyID)
		    dBodyDisable(mBodyID);
	/////////////////////////////////////////////////////
	//}

	// Read Property update Mask Flag.
	if(stream->readFlag())
	{
			
		//stream->read(&mMass);
		stream->readCompressedPoint(&mObjScale);
		//stream->read(&mType);

         if(mOverride = stream->readFlag()) {
               stream->read(&mFriction1);
               stream->read(&mFriction2);
               stream->read(&mBounceVel);
               stream->read(&mBounce);
        }

/*
		dMass mass;
		OdeWorld *world = gClientOdeWorld;
		if(mBodyID){
		   dBodyDestroy(mBodyID);
		}
*/		
		/*if(isServerObject()){ //Add the server objects to the server world.
		   scriptOnAdd();
		   mBodyID = gOdeWorld->addRigidBody();
		   mGeomID = dCreateBox(gOdeWorld->getWorldSpaceID(),mObjScale.x,mObjScale.y,mObjScale.z);
		}else if (isClientObject()){ //Add Client ones to the client world.
		*/
/*		if(mGeomID){
		   dGeomDestroy(mGeomID);
		   mGeomID = 0;
		}
		   
		dBodySetMass(mBodyID,&mass);

		mObjBox.min.set( -0.5*mObjScale.x, -0.5f*mObjScale.y, -0.5*mObjScale.z );
		mObjBox.max.set(  0.5*mObjScale.x, +0.5f*mObjScale.y,  0.5*mObjScale.z );
		// Reset the World Box.
		resetWorldBox();
		// Set the Render Transform.
		setRenderTransform(mObjToWorld);
*/	}
}