dgCollisionCompoundBreakable.h

/* Copyright (c) <2003-2011> <Julio Jerez, Newton Game Dynamics>
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source distribution.
 */

#ifndef AFX_DGCOLLISIONCOMPOUND_BREAKABLE_H__INCLUDED_
#define AFX_DGCOLLISIONCOMPOUND_BREAKABLE_H__INCLUDED_

#include "dgCollisionCompound.h"
#include "dgCollisionConvex.h"

class dgMeshEffect;

class dgCollisionCompoundBreakable : public dgCollisionCompound {
public:
    class dgFlatVertex {
    public:
        dgFloat32 m_point[10]; // 3 point, 3 normal. 2 uv0, 2 uv1
    };

    class dgFlatVertexArray : public dgArray<dgFlatVertex> {
    public:
        dgFlatVertexArray(dgMemoryAllocator *const allocator)
            : dgArray<dgFlatVertex>(1024 * 4, allocator) {
            m_count = 0;
        }

        dgInt32 m_count;
    };

    class dgVertexBuffer : public dgRefCounter {
    public:
        DG_CLASS_ALLOCATOR(allocator)
        dgVertexBuffer(dgInt32 count, dgMemoryAllocator *allocator);
        dgVertexBuffer(dgMemoryAllocator *const allocator, dgDeserialize deserialization, void *const userData);
        ~dgVertexBuffer();

        void Serialize(dgSerialize callback, void *const userData) const;
        void GetVertexStreams(dgInt32 vertexStrideInByte, dgFloat32 *vertex, dgInt32 normalStrideInByte, dgFloat32 *normal,
                              dgInt32 uvStrideInByte, dgFloat32 *uv) const;

        dgInt32 m_vertexCount;
        dgFloat32 *m_uv;
        dgFloat32 *m_vertex;
        dgFloat32 *m_normal;
        dgMemoryAllocator *m_allocator;
    };

    class dgSubMesh {
    public:
        dgSubMesh(dgMemoryAllocator *const allocator);
        ~dgSubMesh();
        void Serialize(dgSerialize callback, void *const userData) const;

        dgInt32 m_faceOffset;
        dgInt32 m_visibleFaces;
        dgInt32 m_material;
        dgInt32 m_faceCount;
        dgInt32 *m_indexes;
        dgMemoryAllocator *m_allocator;
    };

    class dgMesh : public dgList<dgSubMesh>, public dgRefCounter {
    public:
        dgMesh(dgMemoryAllocator *const allocator);
        dgMesh(dgMemoryAllocator *const allocator, dgDeserialize deserialization, void *const userData);
        ~dgMesh();
        void Serialize(dgSerialize callback, void *const userData) const;
        dgSubMesh *AddgSubMesh(dgInt32 indexCount, dgInt32 material);

        dgInt32 m_IsVisible;
    };

    class dgDebriNodeInfo {
    public:
        dgDebriNodeInfo();
        ~dgDebriNodeInfo();

        struct PackedSaveData {
            union {
                dgInt32 m_lru;
                dgInt32 m_shapeID;
            };
            dgInt32 m_distanceToFixNode;
            dgInt32 m_islandIndex;
        } m_commonData;

        dgMesh *m_mesh;
        dgCollisionConvex *m_shape;
    };

    class dgSharedNodeMesh {
    public:
        dgSharedNodeMesh();
        ~dgSharedNodeMesh();
    };

    class dgDebriGraph : public dgGraph<dgDebriNodeInfo, dgSharedNodeMesh> {
    public:
        dgDebriGraph(dgMemoryAllocator *const allocator);
        dgDebriGraph(const dgDebriGraph &source);
        dgDebriGraph(dgMemoryAllocator *const allocator, dgDeserialize deserialization, void *const userData);
        ~dgDebriGraph();

        //      void AddToHeap (dgDownHeap<dgMeshEffect*, dgFloat32>& heap, dgMeshEffect* front);
        void AddNode(dgFlatVertexArray &vertexArray, dgMeshEffect *solid, dgInt32 clipperMaterial, dgInt32 id, dgFloat32 density, dgFloat32 padding);
        //      void SplitAndAddNodes (dgFlatVertexArray& vertexArray, dgMeshEffect* solid, dgMeshEffect* const clipper,
        //                             dgInt32 clipperMaterial, dgInt32 id, dgFloat32 density, dgCollisionCompoundBreakableCallback callback, void* buildUsedData);

        //      void AddMeshes (dgFlatVertexArray& vertexArray, dgInt32 count, dgMeshEffect* const solidArray[], dgMeshEffect* const clipperArray[],
        //                      dgMatrix* const matrixArray, dgInt32* const idArray, dgFloat32* const densities, dgCollisionCompoundBreakableCallback callback, void* buildUsedData);
        void AddMeshes(dgFlatVertexArray &vertexArray, dgInt32 count, dgMeshEffect *const solidArray[],
                       const dgInt32 *const idArray, const dgFloat32 *const densities, const dgInt32 *const internalFaceMaterial, dgFloat32 gaps);

        void Serialize(dgSerialize callback, void *const userData) const;
    };

    class dgIsland : public dgList<dgDebriGraph::dgListNode *> {
    public:
        dgIsland(dgMemoryAllocator *const allocator)
            : dgList<dgDebriGraph::dgListNode *>(allocator) {
        }
    };

    class dgCollisionConvexIntance : public dgCollisionConvex {
    public:
        dgCollisionConvexIntance(dgWorld *const world, dgDeserialize deserialization, void *const userData);
        dgCollisionConvexIntance(const dgCollisionConvexIntance &source, dgDebriGraph::dgListNode *node);
        dgCollisionConvexIntance(dgCollisionConvex *convexChild, dgDebriGraph::dgListNode *node, dgFloat32 density);
        virtual ~dgCollisionConvexIntance();

    protected:
        virtual dgFloat32 GetVolume() const;
        virtual bool OOBBTest(const dgMatrix &matrix, const dgCollisionConvex *const shape, void *const cacheOrder) const;
        virtual dgVector SupportVertex(const dgVector &dir) const;
        virtual dgVector SupportVertexSimd(const dgVector &dir) const;
        virtual void CalcAABB(const dgMatrix &matrix, dgVector &p0, dgVector &p1) const;
        virtual void CalcAABBSimd(const dgMatrix &matrix, dgVector &p0, dgVector &p1) const;
        virtual void DebugCollision(const dgMatrix &matrix, OnDebugCollisionMeshCallback callback, void *const userData) const;
        virtual dgFloat32 RayCast(const dgVector &localP0, const dgVector &localP1, dgContactPoint &contactOut, OnRayPrecastAction preFilter, const dgBody *const body, void *const userData) const;
        virtual dgFloat32 RayCastSimd(const dgVector &localP0, const dgVector &localP1, dgContactPoint &contactOut, OnRayPrecastAction preFilter, const dgBody *const body, void *const userData) const;
        virtual dgVector CalculateVolumeIntegral(const dgMatrix &globalMatrix, GetBuoyancyPlane bouyancyPlane, void *const context) const;

    private:
        virtual dgInt32 CalculateSignature() const;
        virtual void SetCollisionBBox(const dgVector &p0, const dgVector &p1);
        virtual dgFloat32 GetBoxMinRadius() const;
        virtual dgFloat32 GetBoxMaxRadius() const;
        virtual dgInt32 CalculatePlaneIntersection(const dgVector &normal, const dgVector &point, dgVector *const contactsOut) const;
        virtual dgInt32 CalculatePlaneIntersectionSimd(const dgVector &normal, const dgVector &point, dgVector *const contactsOut) const;
        virtual void GetCollisionInfo(dgCollisionInfo *info) const;
        virtual void Serialize(dgSerialize callback, void *const userData) const;

        virtual void SetBreakImpulse(dgFloat32 force);
        virtual dgFloat32 GetBreakImpulse() const;

        dgNodeBase *m_treeNode;
        dgCollisionConvex *m_myShape;
        dgDebriGraph::dgListNode *m_graphNode;
        dgVector m_inertia;
        dgFloat32 m_destructionImpulse;

#ifdef _DEBUG
        dgInt32 m_ordinal;
#endif
        friend class dgCollisionCompoundBreakable;
    };

    class dgCompoundBreakableFilterData {
    public:
        dgInt32 m_index;
        dgDebriGraph::dgListNode *m_node;
    };

    //  class dgSegmenList: public dgList<dgMeshEffect*>
    //  {
    //      public:
    //      dgSegmenList(dgMeshEffect* const source);
    //      ~dgSegmenList();
    //  };

    dgCollisionCompoundBreakable(const dgCollisionCompoundBreakable &source);
    //  dgCollisionCompoundBreakable (dgInt32 count, dgMeshEffect* const solidArray[], dgMeshEffect* const clipperArray[],
    //                                dgMatrix* const matrixArray, dgInt32* const idArray, dgFloat32* const densities, dgInt32 debriiId,
    //                                dgCollisionCompoundBreakableCallback callback, void* buildUsedData, dgWorld* world);

    dgCollisionCompoundBreakable(dgInt32 count, dgMeshEffect *const solidArray[], const dgInt32 *const idArray,
                                 const dgFloat32 *const densities, const dgInt32 *const internalFaceMaterial,
                                 dgInt32 debriiId, dgFloat32 gaps, dgWorld *world);

    dgCollisionCompoundBreakable(dgWorld *const world, dgDeserialize deserialization, void *const userData);
    virtual ~dgCollisionCompoundBreakable(void);

    void DeleteComponentBegin();
    dgBody *CreateComponentBody(dgDebriGraph::dgListNode *node) const;
    void DeleteComponent(dgDebriGraph::dgListNode *node);
    void DeleteComponentEnd();

    dgDebriGraph::dgListNode *GetMainMesh() const {
        return m_conectivity.GetLast();
    }
    dgDebriGraph::dgListNode *GetFirstComponentMesh() const {
        return (m_conectivity.GetCount() > 2) ? m_conectivity.GetFirst()->GetNext() : NULL;
    }
    dgInt32 GetSegmentsInRadius(const dgVector &origin, dgFloat32 radius, dgDebriGraph::dgListNode **segments, dgInt32 maxCount) const;

    void ResetAnchor();
    void SetAnchoredParts(dgInt32 count, const dgMatrix *const matrixArray, dgCollision * const *collisionArray);
    void EnumerateIslands();
    //  dgInt32 GetSegmentsInRadius (const dgVector& origin, dgFloat32 radius, dgDebriGraph::dgListNode** segments, dgInt32 maxCount);
    //  dgInt32 GetDetachedPieces (dgCollision** shapes, dgInt32 maxCount);

    dgInt32 GetSegmentIndexStream(dgDebriGraph::dgListNode *const node, dgMesh::dgListNode *segment, dgInt32 *const index) const;
    dgInt32 GetSegmentIndexStreamShort(const dgDebriGraph::dgListNode *const node, dgMesh::dgListNode *segment, dgInt16 *const index) const;

    dgInt32 GetVertecCount() const {
        return m_vertexBuffer->m_vertexCount;
    }
    void GetVertexStreams(dgInt32 vertexStrideInByte, dgFloat32 *vertex,
                          dgInt32 normalStrideInByte, dgFloat32 *normal,
                          dgInt32 uvStrideInByte, dgFloat32 *uv) const {
        m_vertexBuffer->GetVertexStreams(vertexStrideInByte, vertex, normalStrideInByte, normal, uvStrideInByte, uv);
    }

private:
    void LinkNodes();

    virtual void GetCollisionInfo(dgCollisionInfo *info) const;
    virtual void Serialize(dgSerialize callback, void *const userData) const;

    dgInt32 m_lru;
    dgInt32 m_lastIslandColor;
    dgInt32 m_visibilityMapIndexCount;
    dgInt8 *m_visibilityMap;
    dgInt32 *m_visibilityInderectMap;
    dgVertexBuffer *m_vertexBuffer;
    dgDebriGraph m_conectivity;
    dgIsland m_detachedIslands;
};

#endif