BigRigDemo::BigRigDemo(hkDemoEnvironment* env) : CarDemo(env, false)
{
// Create the vehicles
//
// Create tractor shape.
//
hkpListShape* tractorShape = HK_NULL;
{
hkReal xSize = 1.9f;
hkReal xSizeFrontTop = 0.7f;
hkReal xSizeFrontMid = 1.6f;
hkReal ySize = 0.9f;
hkReal ySizeMid = ySize - 0.7f;
hkReal zSize = 1.0f;
//hkReal xBumper = 1.9f;
//hkReal yBumper = 0.35f;
//hkReal zBumper = 1.0f;
hkVector4 halfExtents(1.0f, 0.35f, 1.0f);
// 16 = 4 (size of "each float group", 3 for x,y,z, 1 for padding) * 4 (size of float).
int stride = sizeof(float) * 4;
{
int numVertices = 10;
float vertices[] = {
xSizeFrontTop, ySize, zSize, 0.0f, // v0
xSizeFrontTop, ySize, -zSize, 0.0f, // v1
xSize, -ySize, zSize, 0.0f, // v2
xSize, -ySize, -zSize, 0.0f, // v3
-xSize, ySize, zSize, 0.0f, // v4
-xSize, ySize, -zSize, 0.0f, // v5
-xSize, -ySize, zSize, 0.0f, // v6
-xSize, -ySize, -zSize, 0.0f, // v7
xSizeFrontMid, ySizeMid, zSize, 0.0f, // v8
xSizeFrontMid, ySizeMid, -zSize, 0.0f, // v9
};
hkpBoxShape* boxShape = new hkpBoxShape(halfExtents, 0.05f );
hkTransform transform;
transform.setIdentity();
transform.setTranslation(hkVector4(-2.5f, -0.55f, 0.0f));
hkpConvexTransformShape* transformShape = new hkpConvexTransformShape(boxShape, transform);
boxShape->removeReference();
hkpConvexVerticesShape* convexShape;
{
hkStridedVertices stridedVerts;
{
stridedVerts.m_numVertices = numVertices;
stridedVerts.m_striding = stride;
stridedVerts.m_vertices = vertices;
}
convexShape = new hkpConvexVerticesShape(stridedVerts);
}
hkArray<hkpShape*> shapeArray;
shapeArray.pushBack(transformShape);
shapeArray.pushBack(convexShape);
tractorShape = new hkpListShape(shapeArray.begin(), shapeArray.getSize());
transformShape->removeReference();
convexShape->removeReference();
}
}
//
// Create trailer shape.
//
hkpListShape* trailerShape = HK_NULL;
{
hkVector4 halfExtents1(5.0f, 1.5f, 1.0f); // Box
hkVector4 halfExtents2(1.0f, 1.0f, 1.0f); // Tongue
hkTransform transform;
transform.setIdentity();
{
hkpBoxShape* boxShape1 = new hkpBoxShape(halfExtents1, 0.05f );
hkpBoxShape* boxShape2 = new hkpBoxShape(halfExtents2, 0.05f );
transform.setTranslation(hkVector4(6.0f, 0.5f, 0.0f));
hkpConvexTransformShape* transformShape = new hkpConvexTransformShape(boxShape2, transform);
boxShape2->removeReference();
hkArray<hkpShape*> shapeArray;
shapeArray.pushBack(boxShape1);
shapeArray.pushBack(transformShape);
trailerShape = new hkpListShape(shapeArray.begin(), shapeArray.getSize());
boxShape1->removeReference();
transformShape->removeReference();
}
}
// Create the tractor vehicles
{
m_world->lock();
{
HK_ASSERT(0x526edf5d, m_world->getCollisionFilter() && m_world->getCollisionFilter()->m_type == hkpCollisionFilter::HK_FILTER_GROUP);
hkpGroupFilter* groupFilter = static_cast<hkpGroupFilter*>(const_cast<hkpCollisionFilter*>(m_world->getCollisionFilter()));
m_vehicles.clear();
for (int vehicleId = 0; vehicleId < m_numVehicles; vehicleId++)
{
int vehicleGroup = groupFilter->getNewSystemGroup();
//
// Create the tractor.
//
{
//
// Create the tractor body.
//
hkpRigidBody* tractorRigidBody;
{
hkpRigidBodyCinfo tractorInfo;
tractorInfo.m_shape = tractorShape;
tractorInfo.m_friction = 0.8f;
tractorInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
tractorInfo.m_collisionFilterInfo = hkpGroupFilter::calcFilterInfo(0, vehicleGroup );
// Position chassis on the ground.
tractorInfo.m_position.set(0.0f, -3.0f, (vehicleId + 1) * 9.0f);
//tractorInfo.m_angularDamping = 0.5f;
// No need to set the inertia tensor, as this will be set automatically by the vehicle setup
tractorInfo.m_mass = 15000.0f;
tractorInfo.m_inertiaTensor.setDiagonal( 1.f, 1.f, 1.f );
tractorInfo.m_centerOfMass.set( -1.0f, -0.8f, 0.0f);
tractorRigidBody = new hkpRigidBody(tractorInfo);
}
m_vehicles.expandOne();
TractorSetup tsetup;
createTractorVehicle( tsetup, tractorRigidBody, m_vehicles.getSize()-1);
tractorRigidBody->removeReference();
}
//
// Create the trailer body.
//
{
hkpRigidBody* trailerRigidBody;
{
hkpRigidBodyCinfo trailerInfo;
trailerInfo.m_shape = trailerShape;
trailerInfo.m_friction = 0.8f;
trailerInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
trailerInfo.m_position.set(-9.0f, -3.0f, (1 + vehicleId) * 9.0f);
trailerInfo.m_collisionFilterInfo = hkpGroupFilter::calcFilterInfo(0, vehicleGroup );
// No need to set the inertia tensor, as this will be set automatically by the vehicle setup
trailerInfo.m_mass = 10000.0f;
trailerInfo.m_inertiaTensor.setDiagonal( 1.f, 1.f, 1.f );
// Trailers are generally bottom-heavy to improve stability.
// Move the centre of mass lower but keep it within the chassis limits.
trailerInfo.m_centerOfMass.set(-1.0f, -1.0f, 0.0f);
trailerRigidBody = new hkpRigidBody(trailerInfo);
}
m_vehicles.expandOne();
TrailerSetup tsetup;
createTrailerVehicle( tsetup, trailerRigidBody, m_vehicles.getSize()-1);
HK_SET_OBJECT_COLOR((hkUlong)trailerRigidBody->getCollidable(), 0x80ff8080);
trailerRigidBody->removeReference();
}
}
tractorShape->removeReference();
trailerShape->removeReference();
}
//
// Create the wheels
//
createDisplayWheels(0.5f, 0.2f);
// Attach Tractors and Trailers
for (int vehicleId = 0; vehicleId < m_vehicles.getSize(); vehicleId+=2)
{
hkpRigidBody* tractor = m_vehicles[vehicleId].m_vehicle->getChassis();
hkpRigidBody* trailer = m_vehicles[vehicleId + 1 ].m_vehicle->getChassis();
//
// Use a hinge constraint to connect the tractor to the trailer
//
if (0)
{
//
// Set the pivot
//
hkVector4 axis(0.0f, 1.0f, 0.0f);
hkVector4 point1(-3.5f, 0.4f, 0.0f);
hkVector4 point2(6.0f, -0.4f, 0.0f);
// Create constraint
hkpHingeConstraintData* hc = new hkpHingeConstraintData();
hc->setInBodySpace(point1, point2, axis, axis);
m_world->createAndAddConstraintInstance( tractor, trailer, hc )->removeReference();
hc->removeReference();
}
//
// Use a ball-and-socket constraint to connect the tractor to the trailer
//
else if (0)
{
hkVector4 point1(-3.5f, 0.4f, 0.0f);
hkVector4 point2(6.0f, -0.4f, 0.0f);
// Create the constraint
hkpBallAndSocketConstraintData* bs = new hkpBallAndSocketConstraintData();
bs->setInBodySpace(point1, point2);
m_world->createAndAddConstraintInstance( tractor, trailer, bs )->removeReference();
bs->removeReference();
}
//
// Use a ragdoll constraint to connect the tractor to the trailer
//
else if(1)
{
hkReal planeMin = HK_REAL_PI * -0.45f;
hkReal planeMax = HK_REAL_PI * 0.45f;
hkReal twistMin = HK_REAL_PI * -0.005f;
hkReal twistMax = HK_REAL_PI * 0.005f;
hkReal coneMin = HK_REAL_PI * -0.55f;
hkReal coneMax = HK_REAL_PI * 0.55f;
hkpRagdollConstraintData* rdc = new hkpRagdollConstraintData();
rdc->setPlaneMinAngularLimit(planeMin);
rdc->setPlaneMaxAngularLimit(planeMax);
rdc->setTwistMinAngularLimit(twistMin);
rdc->setTwistMaxAngularLimit(twistMax);
hkVector4 twistAxisA(1.0f, 0.0f, 0.0f);
hkVector4 planeAxisA(0.0f, 0.0f, 1.0f);
hkVector4 twistAxisB(1.0f, 0.0f, 0.0f);
hkVector4 planeAxisB(0.0f, 0.0f, 1.0f);
hkVector4 point1(-2.3f, -0.7f, 0.0f);
hkVector4 point2( 7.2f, -1.3f, 0.0f);
rdc->setInBodySpace(point1, point2, planeAxisA, planeAxisB, twistAxisA, twistAxisB);
rdc->setAsymmetricConeAngle(coneMin, coneMax);
m_world->createAndAddConstraintInstance(tractor, trailer, rdc)->removeReference();
rdc->removeReference();
}
}
m_world->unlock();
}
//
// Create the camera.
//
{
hkp1dAngularFollowCamCinfo cinfo;
cinfo.m_yawSignCorrection = 1.0f;
cinfo.m_upDirWS.set(0.0f, 1.0f, 0.0f);
cinfo.m_rigidBodyForwardDir.set(1.0f, 0.0f, 0.0f);
cinfo.m_set[0].m_velocity = 10.0f;
cinfo.m_set[1].m_velocity = 50.0f;
cinfo.m_set[0].m_speedInfluenceOnCameraDirection = 1.0f;
cinfo.m_set[1].m_speedInfluenceOnCameraDirection = 1.0f;
cinfo.m_set[0].m_angularRelaxation = 3.5f;
cinfo.m_set[1].m_angularRelaxation = 4.5f;
// The two camera positions ("slow" and "fast" rest positions) are both the same here,
// -6 units behind the chassis, and 2 units above it. Again, this is dependent on
// m_chassisCoordinateSystem.
cinfo.m_set[0].m_positionUS.set( -27.0f, 8.0f, 0.0f);
cinfo.m_set[1].m_positionUS.set( -27.0f, 8.0f, 0.0f);
cinfo.m_set[0].m_lookAtUS.set ( 2.0f, 0.0f, 0.0f );
cinfo.m_set[1].m_lookAtUS.set ( 2.0f, 0.0f, 0.0f );
cinfo.m_set[0].m_fov = 70.0f;
cinfo.m_set[1].m_fov = 70.0f;
m_camera.reinitialize( cinfo );
}
}
TruckDemo::TruckDemo(hkDemoEnvironment* env)
: CarDemo(env, false, 4, 1)
{
m_world->lock();
{
//
// Create vehicle's chassis shape.
//
hkpConvexVerticesShape* chassisShape = HK_NULL;
{
hkReal xSize = 1.9f;
hkReal xSizeFrontTop = 0.7f;
hkReal xSizeFrontMid = 1.6f;
hkReal ySize = 0.9f;
hkReal ySizeMid = ySize - 0.7f;
hkReal zSize = 1.0f;
//hkReal xBumper = 1.9f;
//hkReal yBumper = 0.35f;
//hkReal zBumper = 1.0f;
// 16 = 4 (size of "each float group", 3 for x,y,z, 1 for padding) * 4 (size of float).
int stride = sizeof(float) * 4;
{
int numVertices = 10;
float vertices[] = {
xSizeFrontTop, ySize, zSize, 0.0f, // v0
xSizeFrontTop, ySize, -zSize, 0.0f, // v1
xSize, -ySize, zSize, 0.0f, // v2
xSize, -ySize, -zSize, 0.0f, // v3
-xSize, ySize, zSize, 0.0f, // v4
-xSize, ySize, -zSize, 0.0f, // v5
-xSize, -ySize, zSize, 0.0f, // v6
-xSize, -ySize, -zSize, 0.0f, // v7
xSizeFrontMid, ySizeMid, zSize, 0.0f, // v8
xSizeFrontMid, ySizeMid, -zSize, 0.0f, // v9
};
//
// SHAPE CONSTRUCTION.
//
{
hkStridedVertices stridedVerts;
{
stridedVerts.m_numVertices = numVertices;
stridedVerts.m_striding = stride;
stridedVerts.m_vertices = vertices;
}
chassisShape = new hkpConvexVerticesShape(stridedVerts);
}
}
}
createDisplayWheels(0.5f, 0.3f);
for (int vehicleId = 0; vehicleId < m_numVehicles; vehicleId++)
{
//
// Create the vehicle.
//
{
//
// Create the chassis body.
//
hkpRigidBody* chassisRigidBody;
{
hkpRigidBodyCinfo chassisInfo;
chassisInfo.m_mass = 5000.0f;
chassisInfo.m_shape = chassisShape;
chassisInfo.m_friction = 0.8f;
chassisInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
// Position chassis on the ground.
chassisInfo.m_position.set(-10.0f, -4.5f, vehicleId * 5.0f);
hkpInertiaTensorComputer::setShapeVolumeMassProperties(chassisInfo.m_shape,
chassisInfo.m_mass,
chassisInfo);
chassisRigidBody = new hkpRigidBody(chassisInfo);
}
TruckSetup tsetup;
m_vehicles[vehicleId].m_vehicle = createVehicle( tsetup, chassisRigidBody);
m_vehicles[vehicleId].m_lastRPM = 0.0f;
HK_SET_OBJECT_COLOR((hkUlong)chassisRigidBody->getCollidable(), 0x80ff8080);
// This hkpAction flips the car upright if it turns over.
if (vehicleId == 0)
{
hkVector4 rotationAxis(1.0f, 0.0f, 0.0f);
hkVector4 upAxis(0.0f, 1.0f, 0.0f);
hkReal strength = 8.0f;
m_reorientAction = new hkpReorientAction(chassisRigidBody, rotationAxis, upAxis, strength);
}
chassisRigidBody->removeReference();
}
}
chassisShape->removeReference();
}
//
// Create the camera.
//
{
VehicleApiUtils::createCamera( m_camera );
}
m_world->unlock();
}
VehicleApiDemo::VehicleApiDemo(hkDemoEnvironment* env)
: hkDefaultPhysicsDemo(env)
{
m_tag = 0;
///[driverInput]
/// Initially controller is set to 0,0 i.e. neither turning left/right or forward/backward,
/// so vehicle is not accelerating or turning. ///
m_inputXPosition = 0.0f;
m_inputYPosition = 0.0f;
///>
{
hkVector4 from(0.0f, 0.0f, 10.0f);
hkVector4 to(0.0f, 0.0f, 0.0f);
hkVector4 up(0.0f, 1.0f, 0.0f);
setupDefaultCameras( env, from, to, up );
}
//
// Create the world.
//
{
hkpWorldCinfo info;
info.m_collisionTolerance = 0.1f;
info.m_gravity.set(0.0f, -9.8f, 0.0f);
info.setBroadPhaseWorldSize(1000.0f) ;
info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM);
m_world = new hkpWorld( info );
m_world->lock();
// Register all agents.
hkpAgentRegisterUtil::registerAllAgents(m_world->getCollisionDispatcher());
// Graphics.
setupGraphics();
}
///[buildLandscape]
/// Build the landscape to drive on and add it to m_world. The landscape is simply five
/// boxes, one for the ground and four for the walls.
///
buildLandscape();
///>
///
/// Create the chassis
///
hkpConvexVerticesShape* chassisShape = VehicleApiUtils::createCarChassisShape();
hkpRigidBody* chassisRigidBody;
{
hkpRigidBodyCinfo chassisInfo;
// NB: The inertia value is reset by the vehicle SDK. However we give it a
// reasonable value so that the hkpRigidBody does not assert on construction. See
// VehicleSetup for the yaw, pitch and roll values used by hkVehicle.
chassisInfo.m_mass = 750.0f;
chassisInfo.m_shape = chassisShape;
chassisInfo.m_friction = 0.4f;
// The chassis MUST have m_motionType hkpMotion::MOTION_BOX_INERTIA to correctly simulate
// vehicle roll, pitch and yaw.
chassisInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
chassisInfo.m_position.set(0.0f, 1.0f, 0.0f);
hkpInertiaTensorComputer::setShapeVolumeMassProperties(chassisInfo.m_shape,
chassisInfo.m_mass,
chassisInfo);
chassisRigidBody = new hkpRigidBody(chassisInfo);
// No longer need reference to shape as the hkpRigidBody holds one.
chassisShape->removeReference();
m_world->addEntity(chassisRigidBody);
}
///>
/// In this example, the chassis is added to the Vehicle Kit in the createVehicle() method.
///
createVehicle( chassisRigidBody );
chassisRigidBody->removeReference();
///>
///[buildVehicleCamera]
/// This camera follows the vehicle when it moves.
///
{
VehicleApiUtils::createCamera( m_camera );
}
///>
createDisplayWheels();
m_world->unlock();
}
VehicleManagerDemo::VehicleManagerDemo( hkDemoEnvironment* env, hkBool createWorld, int numWheels, int numVehicles )
: hkDefaultPhysicsDemo( env )
{
const MTVehicleRayCastDemoVariant& variant = g_MTVehicleRayCastDemoVariants[m_variantId];
m_bootstrapIterations = 150;
numVehicles = 50;
m_numVehicles = numVehicles;
m_numWheels = numWheels;
m_vehicles.setSize( m_numVehicles );
setUpWorld();
if (!createWorld)
{
return;
}
m_world->lock();
//
// Create a vehicle manager and a vehicle setup object.
//
VehicleSetup* vehicleSetup;
if ( variant.m_demoType == MTVehicleRayCastDemoVariant::SINGLETHREADED_RAY_CAST || variant.m_demoType == MTVehicleRayCastDemoVariant::MULTITHREADED_RAY_CAST )
{
m_vehicleManager = new hkpVehicleRayCastBatchingManager();
vehicleSetup = new VehicleSetup();
}
else
{
m_vehicleManager = new hkpVehicleLinearCastBatchingManager();
vehicleSetup = new LinearCastVehicleSetup();
}
//
// Setup vehicle chassis and create vehicles
//
{
//
// Create vehicle's chassis shape.
//
hkpConvexVerticesShape* chassisShape = VehicleApiUtils::createCarChassisShape();
createDisplayWheels();
for ( int vehicleId = 0; vehicleId < m_vehicles.getSize(); vehicleId++ )
{
//
// Create the vehicle.
//
{
//
// Create the chassis body.
//
hkpRigidBody* chassisRigidBody;
{
hkpRigidBodyCinfo chassisInfo;
chassisInfo.m_mass = 750.0f;
chassisInfo.m_shape = chassisShape;
chassisInfo.m_friction = 0.8f;
chassisInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
// Position chassis on the ground.
// Inertia tensor will be set by VehicleSetupMultithreaded.
chassisInfo.m_position.set(-40.0f, -4.5f, vehicleId * 5.0f);
chassisInfo.m_inertiaTensor.setDiagonal(1.0f, 1.0f, 1.0f);
chassisInfo.m_centerOfMass.set( -0.037f, 0.143f, 0.0f);
chassisInfo.m_collisionFilterInfo = hkpGroupFilter::calcFilterInfo( CHASSIS_LAYER, 0 );
chassisRigidBody = new hkpRigidBody( chassisInfo );
}
// Create vehicle
{
hkpVehicleInstance *const vehicle = new hkpVehicleInstance( chassisRigidBody );
vehicleSetup->buildVehicle( m_world, *vehicle );
vehicle->addToWorld( m_world );
m_vehicleManager->addVehicle( vehicle );
m_vehicles[vehicleId].m_vehicle = vehicle;
m_vehicles[vehicleId].m_lastRPM = 0.0f;
m_vehicles[vehicleId].m_vehicle->m_wheelCollide->setCollisionFilterInfo( hkpGroupFilter::calcFilterInfo( WHEEL_LAYER, 0 ) );
}
// This hkpAction flips the car upright if it turns over.
if (vehicleId == 0)
{
hkVector4 rotationAxis(1.0f, 0.0f, 0.0f);
hkVector4 upAxis(0.0f, 1.0f, 0.0f);
m_reorientAction = new hkpReorientAction(chassisRigidBody, rotationAxis, upAxis);
}
chassisRigidBody->removeReference();
}
}
chassisShape->removeReference();
}
vehicleSetup->removeReference();
//
// Create the camera.
//
{
VehicleApiUtils::createCamera( m_camera );
m_followCarView = true;
}
m_world->unlock();
//
// Setup for multithreading.
//
hkpCollisionQueryJobQueueUtils::registerWithJobQueue( m_jobQueue );
// register the default addCdPoint() function; you are free to register your own implementation here though
hkpFixedBufferCdPointCollector::registerDefaultAddCdPointFunction();
// Special case for this demo variant: we do not allow the # of active SPUs to drop to zero as this can cause a deadlock.
if ( variant.m_demoType == MTVehicleRayCastDemoVariant::MULTITHREADED_RAY_CAST || variant.m_demoType == MTVehicleRayCastDemoVariant::MULTITHREADED_LINEAR_CAST )
{
m_allowZeroActiveSpus = false;
}
}