True Axis Physics SDK 1.2.0.1 Beta Documentation
www.trueaxis.com

---

PhysicsCollisionGroupMgr.h

//---------------------------------------------------------------------------------
// File Name: PhysicsCollisionGroupMgr.h
// Description: Used to separate objects into groups colliding with each other.
//
// Copyright (C) 2004 - 2006 True Axis Pty Ltd, Australia. 
// All Rights Reserved.
//
// History:
//      Created File.
//---------------------------------------------------------------------------------

#ifndef TA_PHYSICSCOLLISIONGROUPMGR_H
#define TA_PHYSICSCOLLISIONGROUPMGR_H

#ifndef TA_POOL_H
#include "../Common/Pool.h"
#endif // TA_POOL_H

#ifndef TA_PHYSICS_H
#include "Physics.h"
#endif // TA_PHYSICS_H

#ifndef TA_DYNAMICOBJECT_H
#include "DynamicObject.h"
#endif // TA_DYNAMICOBJECT_H

namespace TA
{

class StaticObject;
struct Globals;

//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
class CollisionGroup
{
public:
    typedef Pool<DynamicObjectPair>::ActiveList::Iterator PairIterator;
    typedef Pool<DynamicObject*>::ActiveList::Iterator ObjectPtrIterator;
    class Iterator
    {
    public:
        Iterator() {}
        void operator ++() 
        {
            ++m_itCollision;
            if (m_itCollision.AtEnd())
            {
                ++m_itPair;
                if (!m_itPair.AtEnd())
                    m_itCollision = (*m_itPair).collisionList.GetIterator();
            }
        }
        bool AtEnd() 
        { 
            return (m_itPair.AtEnd() && m_itCollision.AtEnd());
        }
        Collision& operator *() { return *m_itCollision; }
        Iterator& operator = (const Iterator& that) { m_itCollision = that.m_itCollision; m_itPair = that.m_itPair; return *this; }
        bool operator == (const Iterator& that) const { return m_itPair == that.m_itPair && m_itCollision == that.m_itCollision;  }
        void Finalise()
        {
            m_itCollision.Finalise();
            m_itPair.Finalise();
        }

    private:
        friend class CollisionGroup;
        typedef Pool<DynamicObjectPair>::ActiveList::Iterator PairIterator;
        typedef Pool<Collision>::ActiveList::Iterator CollisionIterator;

        CollisionIterator m_itCollision;
        Pool<DynamicObjectPair>::ActiveList::Iterator m_itPair;
        Iterator(Pool<DynamicObjectPair>::ActiveList m_pairList)
        { 
            m_itPair = m_pairList.GetIterator(); 
            if (!m_itPair.AtEnd())
                m_itCollision = (*m_itPair).collisionList.GetIterator();
        }
    };
    
    CollisionGroup();
    ~CollisionGroup();

    Iterator GetIterator() { return Iterator(m_pairList); }
    PairIterator GetPairIterator() { return m_pairList.GetIterator(); }

    ObjectPtrIterator GetObjectPtrIterator() { return m_objectPtrList.GetIterator(); }
    int GetNumCollisions() const { return m_nNumCollisions; }
    int GetNumObjects() const { return m_nNumObjects; }

    void SetFastSolver(bool bFastSolver) { m_bFastSolver = bFastSolver; }
    bool IsFastSolver() { return m_bFastSolver; }

    void SortCollisions(bool bReduceCollisions, int nPass);
    void DoCollisionReduction();
    bool ShouldWeUseHackedFastPhysicsResponse();

    bool ContainsPair(const DynamicObjectPair* pPair);


#ifdef _DEBUG
    void TestNumCollisions();
#else
    void TestNumCollisions() {}
#endif // _DEBUG

private:
    friend class CollisionGroupMgr;

    Globals* m_pGlobals;
    Pool<Collision>::ActiveList m_collisionList;
    Pool<DynamicObjectPair>::ActiveList m_pairList;
    Pool<DynamicObject*>::ActiveList m_objectPtrList;
    int m_nNumCollisions;
    int m_nNumObjects;
    Iterator m_addBefore;
    CollisionGroupMgr* m_pCollisionGroupMgr;
    bool m_bFastSolver;
    
    void Initialise(Globals* pGlobals, CollisionGroupMgr* pCollisionGroupMgr);
    void Finalise();
    //bool AddCollision(Collision& collision);
    void AddPair(DynamicObjectPair& pair);
};

//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
class CollisionGroupMgr
{
public: 
    typedef Pool<CollisionGroup>::ActiveList::Iterator Iterator;
    typedef Pool<Collision>::ActiveList::Iterator GhostCollisionIterator;   
    typedef Pool<DynamicObjectPair>::ActiveListHeadAndTail::Iterator PairIterator;

    CollisionGroupMgr();
    ~CollisionGroupMgr();
    
    void Initialise(Globals* pGlobals, int nMaxNumCollisionsPerGroup);
    void Finalise();
    
    Collision* AddCollision(DynamicObjectPair& pair, const Collision& collision); // Makes a copy of the passed in collision
    void Attach(Collision& attachTo, const Collision& collision); // Makes a copy of the passed in collision
    void AddGhostCollision(DynamicObjectPair& pair, Collision& collision); // Makes a copy of the passed in collision
    void GroupCollisions();

    void ReusePairCollisions(DynamicObjectPair& pair);

    Iterator GetIterator() { return m_groupList.GetIterator(); }
    //GhostCollisionIterator GetGhostCollisionIterator() { return m_ghostCollisionList.GetIterator(); }
    

    void Clear(bool bKeepUnchangedCollisions = false);
    
    void FreeAllCollisionsForPair(DynamicObjectPair& pair);
    void FreePair(DynamicObjectPair& pair); 
    DynamicObjectPair* GetCurrentPair() { return m_pCurrentPair; }
    DynamicObjectPair* AllocatePair();
    void AddPair(DynamicObjectPair* pPair);
    DynamicObjectPair* PopNewPairToProcess();
    DynamicObjectPair* PeekNewPairToProcess();


private:
    friend class CollisionGroup;

    Globals* m_pGlobals;
    Pool<Collision> m_collisionPool;
    //Pool<Collision>::ActiveList m_ghostCollisionList;
    Pool<DynamicObject*> m_objectPtrPool;
    Pool<CollisionGroup> m_groupPool;
    Pool<CollisionGroup>::ActiveList m_groupList; 
    Pool<DynamicObjectPair> m_dynamicObjectPairPool;
    Pool<DynamicObjectPair>::ActiveListHeadAndTail m_pairList;
    Pool<DynamicObjectPair>::ActiveListHeadAndTail m_newPairList;
    DynamicObjectPair* m_pCurrentPair;
    int m_nMaxNumCollisionsPerGroup;

    
    CollisionGroup* MergeCollisionGroups(CollisionGroup* pGroupA, CollisionGroup* pGroupB);
    CollisionGroup* CreateCollisionGroup(DynamicObject* pDynamicObjectA, DynamicObject* pDynamicObjectB);
    void AddObjectToGroup(DynamicObject* pDynamicObjectA, CollisionGroup* pGroup);
    void FreeGroupsCollisions(CollisionGroup& group);
    void FreeCollision(Collision* pCollision);
};

}

#endif // TA_PHYSICSCOLLISIONGROUPMGR_H

---

© Copyright 2004-2006 TRUE AXIS PTY LTD Australia. All rights reserved.