Reality Factory

Code: Select all

  void  PhysicsSetTransform (const NewtonBody* body, const dFloat* matrix)
{
	RenderPrimitive* primitive;

	// get the graphic object form the rigid body
	primitive = (RenderPrimitive*) NewtonBodyGetUserData (body);

	// set the transformation matrix for this rigid body
	dMatrix& mat = *((dMatrix*)matrix);
	primitive->SetMatrix (mat);
}
  

Code: Select all

  float t = 0.0f;
    const float dt = 0.01f;

    float currentTime = 0.0f;
    float accumulator = 0.0f;

    State previous;
    State current;

    while (!quit)
    {
         float newTime = time();
         float deltaTime = newTime - currentTime;
         currentTime = newTime;

         accumulator += deltaTime;

         while (accumulator>=dt)
         {
              previousState = currentState;
              integrate(currentState, t, dt);
              t += dt;
              accumulator -= dt;
         }

         const float alpha = accumulator / dt;

         State state = currentState*alpha + previousState*(1.0f-alpha);

         render(state);
    }

Code: Select all

	//Run now the real physics simulation
	dwTicks = (float)(TimeTicks)/IterationTime;
	geVec3d Pos;
	//Calculate the new positions for all rigid bodies
	//If the engine is slow, run multiple physics loops
	for (int p = 0; p <(1 + dwTicks); p++) 
	{
	    gSim->Advance(AdvanceTime*0.001f);
		for (int nr = 0; nr<sizeInfo.rigidBodiesCount; nr++)
	    {
			//Calculate the new positions for all rigid bodies
			neT3 trans = rBody[nr]->GetTransform();
			geXForm3d M;
			geXForm3d_SetIdentity(&M);
			geVec3d Angles;
			neGeometry *geom;
			rBody[nr]->BeginIterateGeometry(); //get the corresponding actor index number
			int s=0;
			while (geom = rBody[nr]->GetNextGeometry())
			{
				if (s>0)
				{
					neT3 gtrans = geom->GetTransform();
					neT3 gmt = trans * gtrans;
					M.AX = gmt.rot[0][0];
					M.BX = gmt.rot[0][1];
					M.CX = gmt.rot[0][2];
					M.AY = gmt.rot[1][0];
					M.BY = gmt.rot[1][1];
					M.CY = gmt.rot[1][2];
					M.AZ = gmt.rot[2][0];
					M.BZ = gmt.rot[2][1];
					M.CZ = gmt.rot[2][2];
					M.Translation.X = gmt.pos[0];
					M.Translation.Y = gmt.pos[1];
					M.Translation.Z = gmt.pos[2];
					Pos.X = gmt.pos[0];
					Pos.Y = gmt.pos[1];
					Pos.Z = gmt.pos[2];
				}
				else
				{
					M.AX = trans.rot[0][0];
					M.BX = trans.rot[0][1];
					M.CX = trans.rot[0][2];
					M.AY = trans.rot[1][0];
					M.BY = trans.rot[1][1];
					M.CY = trans.rot[1][2];
					M.AZ = trans.rot[2][0];
					M.BZ = trans.rot[2][1];
					M.CZ = trans.rot[2][2];
					M.Translation.X = trans.pos[0];
					M.Translation.Y = trans.pos[1];
					M.Translation.Z = trans.pos[2];
					Pos.X = trans.pos[0];
					Pos.Y = trans.pos[1];
					Pos.Z = trans.pos[2];
				}
				int rgNr = geom->GetUserData();
				CCD->ActorManager()->Position(PhActor[rgNr], Pos);
				geXForm3d_GetEulerAngles(&M, &Angles);
				CCD->ActorManager()->Rotate(PhActor[rgNr], Angles);
				s++;
			}
		}
	}

Code: Select all

//Run now the real physics simulation
   dwTicks = (float)(TimeTicks)/IterationTime;
  
   //Calculate the new positions for all rigid bodies
   //If the engine is slow, run multiple physics loops
   for (int p = 0; p <(1 + dwTicks); p++)
   {
       //Update Physics
       
   }

Code: Select all

        dwTicksGoneBy = CCD->GetTimePassed_F();

	if(dwTicksGoneBy <= 0.0f)
		return RGF_SUCCESS;					// No time passed?  Ignore call!
	
// ...
        thePhysicsManager->Tick(dwTicksGoneBy);

Code: Select all

/* ------------------------------------------------------------------------------------ */
//	Get the amount of time passed since the last call, in milliseconds.
//	..Return the result as a floating-point value.
/* ------------------------------------------------------------------------------------ */
geFloat CCommonData::GetTimePassed_F()
{

	geFloat DeltaTime;

	DeltaTime = (geFloat)TimeCounter - (geFloat)LastTimePoll;

	LastTimePoll = TimeCounter;
	
	LastTimePassed_D = (DWORD)DeltaTime;		// Last elapsed time as DWORD
	LastTimePassed_F = DeltaTime;						// Need in both places
	
	return DeltaTime;
}

Code: Select all

void CPhysicsManager::Tick(geFloat TimeTicks)
{
        float dwTicks = 0.0f;
	dwTicks = (float)(TimeTicks)*IterationTime;

	for (int p = 0; p <(1 + dwTicks); p++) 
	{
                //update your entities etc...

	        float theTick = dwTicks*AdvanceTime;	
		NewtonUpdate (nWorld, theTick);	
	}	
}

Code: Select all

timer tick.                 
elapsed := timer elapsedTime .
 
(elapsed > 0.25) ifTrue:[elapsed:=0.25]   .
accumulatedTime:=accumulatedTime + elapsed.        
 [accumulatedTime >= 0.016] whileTrue:[newtonWorld 
                                     update: 0.016.  
                                     accumulatedTime:=accumulatedTime - 0.016.                                                            
                                      ]. 

Code: Select all

 if(in_pain)
    {
          SetEventState(EntityName#"_Die",true);
    }

Code: Select all

VehicleDemo>>initializeVehicleJoint
          
         "Initialize the receiver's vehicle joint" 

vehicleJoint:= NewtonVehicleJoint world: self newtonWorld
                                         upDirection: (GeVec3D x:0.0 y:1.0 z:0.0 )
                                                  body:  self chassis body. 
                                          
vehicleJoint tireCallback:( GenesisVehicle methodAddressAt:#tirePhysicsUpdate:);
userData: self .

Code: Select all

VehicleDemo>>initializeTires

       "  Initialize the receiver's tires. "
     
     |tire1 tire2 tire3 tire4|   
     
     
tires:=OrderedCollection new.   
                       
tire1:=FrontWheel for: self .
tire1 setupIn: (D3DXVECTOR3 x:-0.90  y:-0.75 z:-1.3).   
self addTire: tire1.      

tire2:=FrontWheel  for: self .
tire2 setupIn: (D3DXVECTOR3 x:0.87 y:-0.75 z:-1.3).  
self addTire: tire2 .

tire3:=RearWheel  for: self .
tire3 setupIn: (D3DXVECTOR3 x:-0.87  y:-0.75 z:1.35).
self addTire: tire3 .

tire4:=RearWheel  for: self .
tire4 setupIn: (D3DXVECTOR3 x:0.87 y:-0.75 z:1.35).
self addTire: tire4  .  

self tires do:[:each | each setupActor]

Code: Select all

VehicleChassis>>initializeBody

         |world inertia origin mass|
         
world:=self parent newtonWorld .             
body:=NewtonRigidBody world: world
                  collision: self bodyCollision.   
                  
body autoFreeze: 0.     
world  unFreezeBody: body . 

body userData: self; 
     transformCallback:(VehicleChassis _methodAddressAt: #transform:from:);
     forceAndTorqueCallback:(VehicleChassis _methodAddressAt:#applyGravityForce:).
                                             
	

inertia:=bodyCollision  calculeInertiaMatrix .                                         
mass:=1000.0.
body massMatrix: mass 
                  inertiaX: (inertia x * mass)
                  inertiaY: (inertia y * mass)
                  inertiaZ: (inertia z * mass).
      	                               
      
origin:=GeVec3D x:0.0 y:0.2 z:0.0.
body centreOfMass: origin;          
      linearDamping:0.0 .
     
self bodyCollision release.

Code: Select all

VehicleWheel>>setupIn: aPosition  

       "Setup the receiver with default values"  

      |position rotation  matrix|
                             
position:=D3DXMATRIX  identity translation: aPosition. 
rotation:= D3DXMATRIX identity rotationY:89.55.  
                               
matrix:= rotation multiply: position .    
                               
                            
id:=WINAPI NewtonVehicleAddTire: self vehicleJoint 
                       with: matrix  basicAddress 
                       with: (GeVec3D x:0.0 y:0.0 z:1.0) basicAddress
                       with: self mass
                       with: self width
                       with: self radius
                       with: self suspensionShock
                       with: self suspensionSpring
                       with: self suspensionLength
                       with: self basicAddress
                       with: 0x100 .

Code: Select all

VehicleDemo(Class)>>controlCallback: pVehicleJoint

     |vehicle|
     
vehicle:= NewtonVehicleJoint userDataFrom: pVehicleJoint.

vehicle control.

^NULL

Code: Select all

VehicleDemo>>control

            |omega count|

omega := 0.0.
count := 0            .
self tires do:[:each | omega:= omega + each omeg]            .

omega:= (omega / 4.0) abs.

self manualTransmission ifFalse:[

"& (omegaIsPositive)"
((self currentGear = 1)&  (omega <= 1.0)  & (self brakesOn))
	                     ifTrue:[ self currentGear: 0].
	

(self currentGear = 0)	ifTrue:[	
	(self throttle = 0.0)not ifTrue:[ self currentGear: 1]
				            ifFalse:[ (self brakeOn) ifTrue:[ self mThrottle:1.0;
				                                            	brakesOn: false]
 			                        ]. 
 			                        
 			                    ]    
		                        ]

Code: Select all

VehicleDemo(Class)>>tirePhysicsUpdate: pVehicleJoint          
            
       " Update tire physics of the receiver"  
          
        |vehicle|       
                   
vehicle:= NewtonVehicleJoint userDataFrom: pVehicleJoint .           
            
vehicle tirePhysics.         
                                                       

^NULL

Code: Select all

VehicleDemo>>tirePhysics
     
     "Apply tire physics"
                   
self tires do:[:each | each tirePhysics]. 

Code: Select all

VehicleRearWheel>>tirePhysics
              
                 |speed  brakeAcceleration |
                     

	
                          
                                               
(brakes > 0.0) ifTrue:[
		 
		brakeAcceleration := self vehicleJoint calculateMaxBrakeAccelerationFor: self id.
		
		

" tell Newton you want this tire stooped but only if the torque need it is less than 
 the brakes pad can withstand (assume max brake pad torque is 500 newton * meter)"

		self vehicleJoint brakeAccelerationFor:  self id 
		                          acceleration: brakeAcceleration
		                          maxFrictionTorque:1500.0 .
		

 " set some side slip as function of the linear speed "
		
		speed := self vehicleJoint longitudinalSpeedFor: self id  .
		self vehicleJoint maxSideSleepSpeedFor: self id with: speed *1000  ]
		
		
ifFalse:[brakes = 0.0].          

                      
 super tirePhysics.
                                  
   WINAPI NewtonVehicleSetTireTorque: self vehicleJoint
	                             with: self id
	                             with: self torque .

Code: Select all

VehicleFrontWheel>>tirePhysics

        | speed load delta | 


                    

WINAPI	NewtonVehicleSetTireSteerAngle: vehicleJoint
                                  with: self id
                                  with:  steerAngle.                    
super tirePhysics   . 

Code: Select all

VehicleWheel>>tirePhysics
                
                  |speed load  |
                                   
                  
 speed := (self omega "* radius* 3.6") abs.
load  := self normalLoad.
		
                      
self maxSideSleepSpeed:  (speed * 0.1) ;
     sideSleepCoefficient: (speed * load * load *0.8)  .
                 
speed := self longitudinalSpeed.
                    
self maxLongitudinalSlideSpeed: (speed *0.1 );
	longitudinalSlideCoefficient: ( speed * load *load* 0.8 ) .