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

---

CollisionObjectCachedPolyData.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------
// File Name: CollisionObjectCachedPolyData.h
// Description: 
//      Used to put polygon data into on the fly for collision detection against
//      other collision object types. Used for collision detection against
//      CollisionObjectAABBMesh which uses an AABB tree.
//
// Copyright (C) 2004 - 2006 True Axis Pty Ltd, Australia. 
// All Rights Reserved.
//
// History:
//      Created File.
//---------------------------------------------------------------------------------

#ifndef TA_COLLISIONOBJECTCACHEDPOLYDATA_H
#define TA_COLLISIONOBJECTCACHEDPOLYDATA_H

#ifndef TA_ARRAY_H
#include "../Common/Array.h"
#endif // TA_ARRAY_H

#ifndef TA_AABBTREE_H
#include "../Common/AABBTree.h" // would be nice if this header file could be avoided here
#endif // TA_AABBTREE_H

#ifndef TA_COLLISIONCONSTANTS_H
#include "CollisionConstants.h"
#endif // TA_COLLISIONCONSTANTS_H

#ifndef TA_COLLISION_H
#include "Collision.h"
#endif // TA_COLLISION_H

#ifndef TA_COLLISIONOBJECT_H
#include "CollisionObject.h"
#endif // TA_COLLISIONOBJECT_H

TA_OBFUSCATION_SKIP_PASS_2

namespace TA
{

struct AABB;
class CollisionObjectSimple;

class CollisionObjectCachedPolyData : public CollisionObject
{
public:
    TA_OBFUSCATION_RESERVED_ON
    struct Vertex
    {
        const Vec3& GetPosition();
        void SetPosition(const Vec3& v3Position);
        const Vec3& GetEdgeNormal();
        void SetEdgeNormal(const Vec3& v3EdgeNormal);
        TA_OBFUSCATION_RESERVED_OFF
#ifndef TA_COLLISION_FRIEND
    private:
#endif // TA_COLLISION_FRIEND
        Vec3 v3Position;
        Vec3 v3EdgeNormal;
    };
    TA_OBFUSCATION_RESERVED_ON
    struct Polygon // Pseudo polygon structure
    {
        const Vec3& GetNormal();
        void SetNormal(const Vec3& v3Normal);
        int GetAttribute() const;
        void SetAttribute(int nAttribute);
        int GetNumVertices() const;
        void SetCollisionID(u32 nCollisionID);
        u32 GetCollisionID() const;
        //void SetNumVertices(int nNumVertices);
        Vertex& GetVertex(int nIndex);
        const Vertex& GetVertex(int nIndex) const;
        void GenerateEdgeNormals();
        TA_OBFUSCATION_RESERVED_OFF
#ifndef TA_COLLISION_FRIEND
    private:
#endif // TA_COLLISION_FRIEND       
        Vec3 v3Normal;
        int nAttribute;
        int nNumVertices;
        u32 nCollisionID;
        u32 nPadd1;
        Vertex pVertexList[k_nMaxNumVerticesInPolygon];
    };

    void Initialise();
    void Finalise();

    TA_OBFUSCATION_RESERVED_ON
    void Clear();
    Polygon* GetNewPolygon(int nNumVertices);
    TA_OBFUSCATION_RESERVED_OFF
    //void CacheLocalPolygonOfMesh(const CollisionObjectComplex& collisionObjectComplex, const AABB& aabb);

#ifndef DOXYGEN
    const u8* GetData() const { return &m_data[0]; }
    const u8* GetDataPtrAt(int nIndex) const { return &m_data[nIndex]; }
    int GetDataSize() const { return m_data.GetSize(); }
    static int TAC_CALL CalculatePolygonSize(int nNumVertices) { return sizeof (Vec3) + sizeof (int) * 4 + sizeof (Vertex) * nNumVertices; }
#endif // DOXYGEN

#ifndef DOXYGEN
    virtual bool TestLineForCollision(
        const Vec3& v3Start,
        const Vec3& v3Normal,
        float fLength,
        Collision& collision) const { return false; }

    CollisionObject* GetCachedFrom() { return m_pCachedFrom; }
    void SetCachedFrom(CollisionObject* pCachedFrom) { m_pCachedFrom = pCachedFrom; }

    TA_DEFINE_FRIEND_SIMPLE_VS_COMPLEX_COLLISION(TestConvexObjectAgainstCachedPolyData)     

#endif // DOXYGEN

    static CollisionObjectCachedPolyData* TAC_CALL CreateNew();

protected:
    CollisionObjectCachedPolyData();
    ~CollisionObjectCachedPolyData();   

private:
    Array<u8, false> m_data;

    virtual const AABB& GetAABB() const { return NoGetAABB(); }

    static void TAC_CALL AABBTreeCallback(AABBTree::Item* pItem, void* pData);
    CollisionObject* m_pCachedFrom;
};

inline const Vec3& CollisionObjectCachedPolyData::Vertex::GetPosition() { return v3Position; }
inline void CollisionObjectCachedPolyData::Vertex::SetPosition(const Vec3& v3Position) { this->v3Position = v3Position; }
inline const Vec3& CollisionObjectCachedPolyData::Vertex::GetEdgeNormal() { return v3EdgeNormal; }
inline void CollisionObjectCachedPolyData::Vertex::SetEdgeNormal(const Vec3& v3EdgeNormal) { this->v3EdgeNormal = v3EdgeNormal; }
inline const Vec3& CollisionObjectCachedPolyData::Polygon::GetNormal() { return v3Normal; }
inline void CollisionObjectCachedPolyData::Polygon::SetNormal(const Vec3& v3Normal) { this->v3Normal = v3Normal; }
inline int CollisionObjectCachedPolyData::Polygon::GetAttribute() const { return nAttribute; }
inline void CollisionObjectCachedPolyData::Polygon::SetCollisionID(u32 nCollisionID) { this->nCollisionID = nCollisionID; }
inline u32 CollisionObjectCachedPolyData::Polygon::GetCollisionID() const { return nCollisionID; }
inline void CollisionObjectCachedPolyData::Polygon::SetAttribute(int nAttribute) { this->nAttribute = nAttribute; }
inline int CollisionObjectCachedPolyData::Polygon::GetNumVertices() const { return nNumVertices; }
//inline void CollisionObjectCachedPolyData::Polygon::SetNumVertices(int nNumVertices) { this->nNumVertices = nNumVertices; }
inline CollisionObjectCachedPolyData::Vertex& CollisionObjectCachedPolyData::Polygon::GetVertex(int nIndex) { TA_ASSERT(nIndex >= 0); TA_ASSERT(nIndex < nNumVertices); return pVertexList[nIndex]; }
inline const CollisionObjectCachedPolyData::Vertex& CollisionObjectCachedPolyData::Polygon::GetVertex(int nIndex) const { return pVertexList[nIndex]; }
inline void CollisionObjectCachedPolyData::Clear() { m_data.Clear(); }

#ifndef DOXYGEN

void TAC_CALL CollisionObjectCachedPolyData_InitialisePointAndEdgeCollisions();

void TAC_CALL CollisionObjectCachedPolyData_ProcessPointAndEdgeCollisions(CollisionCallData* pCollisionCallData);

void TAC_CALL CollisionObjectCachedPolyData_AddPointCollision(
    float fTime,
    float fIntersectingDepth,
    const CollisionObjectCachedPolyData::Polygon* pPolygon,
    int nVertex,
    bool bConstrain,
    const Vec3& v3PointPosition,
    const Vec3& v3CollisionPosition,
    const Vec3& v3Normal);

void TAC_CALL CollisionObjectCachedPolyData_DisallowPointCollision(
    const Vec3& v3PointCollision,
    const Vec3& v3EdgeDir);

enum 
{ 
    DISALLOW_POINT_COLLISION_CONSTRAINED_TO_FACE = 0,
    DISALLOW_POINT_COLLISION_CONSTRAINED_TO_EDGE,
};

void TAC_CALL CollisionObjectCachedPolyData_DisallowPointCollision(
    const Vec3& v3PointCollision,
    int nType);

void TAC_CALL CollisionObjectCachedPolyData_AddEdgeCollision(
    float fTime,
    float fIntersectingDepth,
    u32 nAttribute,
    const Vec3& v3EdgePosA,
    const Vec3& v3EdgePosB,
    const Vec3& v3CollisionPosition,
    const Vec3& v3Normal,
    int nType);

void TAC_CALL CollisionObjectCachedPolyData_DisallowEdgeCollision(
    const Vec3& v3EdgePosA,
    const Vec3& v3EdgePosB,
    int nType);

#endif // DOXYGEN

};


#endif // TA_COLLISIONOBJECTCACHEDPOLYDATA_H

---

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