Premiers pas avec Havok

#include <Common/Base/hkBase.h>

#include <Common/Base/System/hkBaseSystem.h>

#include <Common/Base/Memory/hkThreadMemory.h>
#include <Common/Base/Memory/Pool/hkPoolMemory.h>

#include <Common/Base/Thread/Job/ThreadPool/Cpu/hkCpuJobThreadPool.h>
#include <Common/Base/Thread/JobQueue/hkJobQueue.h>

// Keycode
#include <Common/Base/keycode.cxx>

#if !defined USING_HAVOK_PHYSICS
#error Physics is needed to build this demo. It is included in the common package for reference only.
#endif

// Classlists
#define INCLUDE_HAVOK_PHYSICS_CLASSES
#define HK_CLASSES_FILE <Common/Serialize/Classlist/hkClasses.h>
#include <Common/Serialize/Util/hkBuiltinTypeRegistry.cxx>

// Generate a custom list to trim memory requirements
#define HK_COMPAT_FILE <Common/Compat/hkCompatVersions.h>
#include <Common/Compat/hkCompat_None.cxx>

// le premier paramètre est assez évident, le message que l'on souhaite
// afficher, et le deuxième (ici on ne s'en sert pas) est l'adresse de
// l'objet générant l'erreur
static void HK_CALL errorReport(const char* msg, void*)
{
    printf("%s", msg);
}

hkPoolMemory* memoryManager = new hkPoolMemory();
hkThreadMemory* threadMemory = new hkThreadMemory(memoryManager);
hkBaseSystem::init( memoryManager, threadMemory, errorReport );
memoryManager->removeReference();

// affecte une certaine quantité de mémoire pour la gestion interne d'Havok
char* stackBuffer;
{
    int stackSize = 0x100000;
    stackBuffer = hkAllocate<char>( stackSize, HK_MEMORY_CLASS_BASE);
    hkThreadMemory::getInstance().setStackArea( stackBuffer, stackSize);
}

hkJobThreadPool* threadPool;

int totalNumThreadsUsed;

hkHardwareInfo hwInfo;
hkGetHardwareInfo(hwInfo);
totalNumThreadsUsed = hwInfo.m_numThreads;

hkCpuJobThreadPoolCinfo threadPoolCinfo;
threadPoolCinfo.m_numThreads = totalNumThreadsUsed - 1;

threadPoolCinfo.m_timerBufferPerThreadAllocation = 200000;
threadPool = new hkCpuJobThreadPool( threadPoolCinfo );

hkJobQueueCinfo info;
info.m_jobQueueHwSetup.m_numCpuThreads = totalNumThreadsUsed;
hkJobQueue* jobQueue = new hkJobQueue(info);

hkMonitorStream::getInstance().resize(200000);

hkpWorld* physicsWorld;

// structure contenant les caractéristiques du monde
hkpWorldCinfo worldInfo;

// type de simulation
worldInfo.m_simulationType = hkpWorldCinfo::SIMULATION_TYPE_MULTITHREADED;

// comportement des objets à la limite du monde
worldInfo.m_broadPhaseBorderBehaviour = hkpWorldCinfo::BROADPHASE_BORDER_REMOVE_ENTITY;

physicsWorld = new hkpWorld(worldInfo);

// comportement des objets dont la vitesse est quasiment nulle
physicsWorld->m_wantDeactivation = false;

// début de la section critique
physicsWorld->markForWrite();

hkpAgentRegisterUtil::registerAllAgents( physicsWorld->getCollisionDispatcher() );

physicsWorld->registerWithJobQueue( jobQueue );

// fin de la section critique
physicsWorld->unmarkForWrite();

// pour définir une boite (alignée sur les axes), on donne un vecteur
// correspondant à une demi-diagonale.
// Ici, notre boite « mesurera » 100.0f x 2.0f x 100.0f
hkVector4 demiDiagonaleDuSol( 50.0f, 1.0f, 50.0f );

// on crée l'objet qui va définir notre boite
hkpConvexShape *solide = new hkpBoxShape( demiDiagonaleDuSol, 0.0f );

// la variable ci contient des informations à propos de notre solide physique
hkpRigidBodyCinfo ci;

// on spécifie ici que notre solide physique aura les dimensions
// de notre boite ci-dessus
ci.m_shape = solide;

// notre solide sera fixe dans notre monde
ci.m_motionType = hkpMotion::MOTION_FIXED;

// position du centre de notre solide
ci.m_position = hkVector4( 0.0f, -1.0f, 0.0f );

// spécifie « l'algo » qui sera utilisé pour tester les collisions
// avec notre solide
ci.m_qualityType = HK_COLLIDABLE_QUALITY_FIXED;

// ajoute le solide au monde et libère les objets devenus inutiles
physicsWorld->addEntity( new hkpRigidBody( ci ) )->removeReference();
solide->removeReference();

// la classe pour les propriétés de notre future sphère
hkpRigidBodyCinfo sphereInfo;

// attention c'est technique, ici on calcule le centre de gravité, ainsi qu'une
// matrice qui va indiquer comment va se comporter notre objet lors de rotations
// sur lui-même, grosso modo comment se répartit la masse de notre objet
// autour de son centre de gravité
// notre sphère pèse 100.0f et a pour rayon 1.0f
hkpMassProperties massProperties;
hkpInertiaTensorComputer::computeSphereVolumeMassProperties(1.0f, 100.0f, massProperties);

// remplissage des informations sur notre sphère
sphereInfo.m_mass = massProperties.m_mass;
sphereInfo.m_centerOfMass  = massProperties.m_centerOfMass;
sphereInfo.m_inertiaTensor = massProperties.m_inertiaTensor;
sphereInfo.m_shape = new hkpSphereShape( 1.0f );
sphereInfo.m_position = hkVector4( 0.0f, 10.0f, 0.0f );
sphereInfo.m_motionType = hkpMotion::MOTION_SPHERE_INERTIA;

// voici un nouvel « algo » de collision, celui-ci permet de ne pas louper
// de collision quand un des objets peut avoir une vitesse élevée
sphereInfo.m_qualityType = HK_COLLIDABLE_QUALITY_BULLET;

// création de notre objet avec toutes ses caractéristiques
hkpRigidBody* sphereRigidBody = new hkpRigidBody( sphereInfo );

// ajout de notre objet à la scène et libération des ressources
physicsWorld->addEntity( sphereRigidBody );
sphereRigidBody->removeReference();
sphereInfo.m_shape->removeReference();

// quel que soit l'objet que l'on va créer, on remplit encore la classe
// hkpRigidBodyCinfo
hkpRigidBodyCinfo boxInfo;

// on renseigne la masse de notre boite
boxInfo.m_mass = 10.0f;

hkVector4 demiDiagonaleDeLaBoite( 2.0f, 2.0f, 2.0f );

hkpConvexShape *solide = new hkpBoxShape( demiDiagonaleDeLaBoite, 0.0f );

// de la même manière que pour la sphère on calcule des propriétés
// avancées pour notre boite
hkpMassProperties massProperties;
hkpInertiaTensorComputer::computeBoxVolumeMassProperties(demiDiagonaleDeLaBoite, boxInfo.m_mass, massProperties);

boxInfo.m_mass = massProperties.m_mass;
boxInfo.m_centerOfMass = massProperties.m_centerOfMass;
boxInfo.m_inertiaTensor = massProperties.m_inertiaTensor;
boxInfo.m_shape = solide;

// voici un champ qu'on n'a pas encore vu, celui-ci (compris entre 0.0 et 1.0)
// permet de calculer la quantité d'énergie qui sera conservée
// lors de la collision entre notre boite et un autre objet de la scène
boxInfo.m_restitution = 1.0f;

boxInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;

boxInfo.m_position = hkVector4( 0.1f, 15.0f, 0.0f );
hkpRigidBody* boxRigidBody = new hkpRigidBody( boxInfo );
physicsWorld->addEntity( boxRigidBody );
boxRigidBody->removeReference();
boxInfo.m_shape->removeReference();

// on souhaiterait 60 mises à jour de notre simulation par seconde
const float fTimeStep = 1.0f/60.0f;

// à insérer dans notre fonction de rendu
// elapsedTime correspondant au temps depuis le dernier appel
// ce code « garantit » donc un appel presque régulier à la mise à
// jour de notre scène du point de vue physique
fTimeAccumulateur += float(elapsedTime);
while( fTimeAccumulateur > fTimeStep )
{
    physicsWorld->stepMultithreaded( jobQueue, threadPool, fTimeStep );
    this->m_fTimeAccumulateur -= fTimeStep;
}

// on pose un verrou vu qu'on va modifier notre monde
physicsWorld->markForWrite();
physicsWorld->removeReference();

delete jobQueue;

threadPool->removeReference();

threadMemory->setStackArea(0, 0);
hkDeallocate( stackBuffer );

threadMemory->removeReference();

// pendant de la fonction init
hkBaseSystem::quit();

#ifndef HK_MyTestDemo_H
#define HK_MyTestDemo_H

#include <Demos/DemoCommon/DemoFramework/hkDefaultPhysicsDemo.h>

class MyTestDemo : public hkDefaultPhysicsDemo
{
    public:

        HK_DECLARE_CLASS_ALLOCATOR(HK_MEMORY_CLASS_DEMO);

        MyTestDemo(hkDemoEnvironment* env);
};

#endif

#include <Demos/demos.h>
#include <Demos/Physics/Api/MyTest/MyTestDemo.h>

MyTestDemo::MyTestDemo(hkDemoEnvironment* env) : hkDefaultPhysicsDemo(env)
{
    // configuration de la caméra
    {
        hkVector4 from(0.0f, 7.0f, 25.0f);
        hkVector4 to  (0.0f, 3.0f,  0.0f);
        hkVector4 up  (0.0f, 1.0f,  0.0f);
        setupDefaultCameras( env, from, to, up );
    }

    // création du monde
    {
        hkpWorldCinfo info;
        info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM); 
        info.setBroadPhaseWorldSize( 100.0f );
        // seuil de tolérance pour les collisions, les unités étant celles du système international
        // on obtient donc une tolérance de 4 cm
        info.m_collisionTolerance = 0.04f;
        info.m_contactRestingVelocity = 0.2f;
        m_world = new hkpWorld( info );
        m_world->lock();
		
        setupGraphics();
    }

    {
        hkpAgentRegisterUtil::registerAllAgents(m_world->getCollisionDispatcher());
    }

    // le sol
    {
        // pour définir une boite (alignée sur les axes) on donne un vecteur
        // correspondant à une demi-diagonale, donc ici, notre boite
        // « mesurera » 100.0f x 2.0f x 100.0f
        hkVector4 demiDiagonaleDuSol( 50.0f, 1.0f, 50.0f );

        // on créé l'objet qui va définir notre boite
        hkpConvexShape *solide = new hkpBoxShape( demiDiagonaleDuSol, 0.0f );

        // cet objet contient des informations à propos de notre solide physique
        hkpRigidBodyCinfo ci;

        // on spécifie ici que notre solide physique aura les dimensions
        // de notre boite ci-dessus
        ci.m_shape = solide;

        // notre solide sera fixe dans notre monde
        ci.m_motionType = hkpMotion::MOTION_FIXED;

        // position du centre de notre solide
        ci.m_position = hkVector4( 0.0f, -1.0f, 0.0f );

        // spécifie « l'algo » qui sera utilisé pour tester les collisions
        // avec notre solide
        ci.m_qualityType = HK_COLLIDABLE_QUALITY_FIXED;

        // ajoute le solide au monde et libère les objets devenus inutiles
        m_world->addEntity( new hkpRigidBody( ci ) )->removeReference();
        solide->removeReference();
    }

    // la sphère
    {
        // la classe pour les propriétés de notre future sphère
        hkpRigidBodyCinfo sphereInfo;

        // attention c'est technique, ici on calcule le centre de gravité, ainsi qu'une
        // matrice qui va indiquer comment va se comporter notre objet lors de rotations
        // sur lui-même, grosso modo comment se répartit la masse de notre objet
        // autour de son centre de gravité
        // notre sphère pèse 100.0f et a pour rayon 1.0f
        hkpMassProperties massProperties;
        hkpInertiaTensorComputer::computeSphereVolumeMassProperties(1.0f, 100.0f, massProperties);

        // remplissage des informations sur notre sphère
        sphereInfo.m_mass = massProperties.m_mass;
        sphereInfo.m_centerOfMass  = massProperties.m_centerOfMass;
        sphereInfo.m_inertiaTensor = massProperties.m_inertiaTensor;
        sphereInfo.m_shape = new hkpSphereShape( 1.0f );
        sphereInfo.m_position = hkVector4( 0.0f, 10.0f, 0.0f );
        sphereInfo.m_motionType = hkpMotion::MOTION_SPHERE_INERTIA;

        // voici un nouvel « algo » de collision, celui-ci permet de ne pas louper
        // de collision quand un des objets peut avoir une vitesse élevée
        sphereInfo.m_qualityType = HK_COLLIDABLE_QUALITY_BULLET;

        // création de notre objet avec toutes ses caractéristiques
        hkpRigidBody* sphereRigidBody = new hkpRigidBody( sphereInfo );

        // ajout de notre objet à la scène et libération des ressources
        m_world->addEntity( sphereRigidBody );
        sphereRigidBody->removeReference();
        sphereInfo.m_shape->removeReference();
    }

    // la boite
    {
        // quel que soit l'objet que l'on va créer, on remplit encore la classe
        // hkpRigidBodyCinfo
        hkpRigidBodyCinfo boxInfo;

        // on renseigne la masse de notre boite
        boxInfo.m_mass = 10.0f;

        hkVector4 demiDiagonaleDeLaBoite( 2.0f, 2.0f, 2.0f );

        hkpConvexShape *solide = new hkpBoxShape( demiDiagonaleDeLaBoite, 0.0f );

        // de la même manière que pour la sphère on calcule des propriétés
        // avancées pour notre boite
        hkpMassProperties massProperties;
        hkpInertiaTensorComputer::computeBoxVolumeMassProperties(demiDiagonaleDeLaBoite, boxInfo.m_mass, massProperties);

        boxInfo.m_mass = massProperties.m_mass;
        boxInfo.m_centerOfMass = massProperties.m_centerOfMass;
        boxInfo.m_inertiaTensor = massProperties.m_inertiaTensor;
        boxInfo.m_shape = solide;

        // voici un champ qu'on n'a pas encore vu, celui-ci (compris entre 0.0 et 1.0)
        // permet de calculer la quantité d'énergie qui sera conservée
        // lors de la collision entre notre boite et un autre objet de la scène
        boxInfo.m_restitution = 1.0f;

        boxInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;

        boxInfo.m_position = hkVector4( 0.1f, 15.0f, 0.0f );
        hkpRigidBody* boxRigidBody = new hkpRigidBody( boxInfo );
        m_world->addEntity( boxRigidBody );
        boxRigidBody->removeReference();
        boxInfo.m_shape->removeReference();
    }

    m_world->unlock();
}

#if defined(HK_COMPILER_MWERKS)
#	pragma force_active on
#	pragma fullpath_file on
#endif

static const char helpString[] = "une simple application de test.";

HK_DECLARE_DEMO(MyTestDemo, HK_DEMO_TYPE_PRIME, "notre demo", helpString);

// tout d'abord les nouveaux headers nécessaires pour l'utilisation du visual debugger
#include <Common/Visualize/hkVisualDebugger.h>
#include <Physics/Utilities/VisualDebugger/hkpPhysicsContext.h>

[...]

// contexts va contenir la liste des éléments qui vont être monitorés
hkArray<hkProcessContext*> contexts;

// on remplit un contexte avec les éléments que l'on veut monitorer
hkpPhysicsContext* context;
{
	context = new hkpPhysicsContext();
	hkpPhysicsContext::registerAllPhysicsProcesses();
	
	// on ajoute notre joli monde physique ...
	context->addWorld(physicsWorld);
	
	// ... et on ajoute le contexte à la liste de "monitorage"
	contexts.pushBack(context);
}

// et voilà la partie qui va servir à envoyer les informations à travers le réseau
hkVisualDebugger* vdb = new hkVisualDebugger(contexts);
vdb->serve();

// !!! pendant la simulation
// envoie un pas de simulation au visual debugger, on assure au préalable que les temps entre les différents processus sont synchronisés
context->syncTimers( threadPool );
vdb->step();

// nettoyage
vdb->removeReference();
context->removeReference();

// pose d'un verrou en lecture sur les informations de notre simulation
physicsWorld->markForRead();

hkVector4 position;
hkQuaternion orientation;

// chassisRigidBody pointeur vers notre objet de classe hkpRigidBody
position = chassisRigidBody->getPosition();
orientation = chassisRigidBody->getRotation();

// libération du verrou
physicsWorld->unmarkForRead();

// code pour l'affectation d'un hkQuaternion et d'un hkVector4
// à respectivement un D3DXQUATERNION et un D3DXVECTOR4
hkQuaternion hkQuat;
D3DXQUATERNION dxQuat( hkQuat(0), hkQuat(1), hkQuat(2), hkQuat(3) );

hkVector4 hkV4;
D3DXVECTOR4 dxV4( hkV4(0), hkV4(1), hkV4(2), hkV4(3) );