for (irr::u32 m = 0; m < MBCount; m++)
{
    irr::scene::IMeshBuffer* MB = GetMesh()->getMeshBuffer(m);

    irr::video::S3DVertex* Vertices = (irr::video::S3DVertex*)MB->getVertices();
    irr::u16* Indices = MB->getIndices();

    for (irr::u32 i = 0; i < MB->getIndexCount(); i++)
    {
        v_Indices.push_back((int)Indices[i]);
    }
    for (irr::u32 i = 0; i < MB->getVertexCount(); i++)
    {
        v_Vertices.push_back((float)Vertices[i].Pos.X);
        v_Vertices.push_back((float)Vertices[i].Pos.Y);
        v_Vertices.push_back((float)Vertices[i].Pos.Z);
    }
}

btCompoundShape* p_Shape = CreateShapeHACD(v_Vertices, v_Indices);

printf("Bn");
    btAlignedObjectArray<btTriangleMesh*> m_trimeshes;
    btAlignedObjectArray<btConvexHullShape*> m_convexShapes;
    btAlignedObjectArray<btVector3> m_convexCentroids;

    printf("Cn");
    std::vector<HACD::Vec3<HACD::Real>> Points;
    std::vector<HACD::Vec3<long>> Triangles;

    printf("Dn");
    for (unsigned int i = 0; i < i_Vertices.size(); i++)
    {
        unsigned int Index = i * 3;
        HACD::Vec3<HACD::Real> Vertex(i_Vertices[Index], i_Vertices[Index + 1], i_Vertices[Index + 2]);
        Points.push_back(Vertex);
    }
    printf("En");
    for (unsigned int i = 0; i < i_Indices.size() * 3; i++)
    {
        unsigned int Index = i * 3;
        HACD::Vec3<long> Triangle(i_Indices[Index], i_Indices[Index + 1], i_Indices[Index + 2]);
        Triangles.push_back(Triangle);
    }

    printf("Fn");
    //
    //  Let HACD do it's thing
    //

    printf("Gn");
    HACD::HACD myHACD;
    myHACD.SetPoints(&Points[0]);
    myHACD.SetNPoints(Points.size());
    myHACD.SetTriangles(&Triangles[0]);
    myHACD.SetNTriangles(Triangles.size());
    myHACD.SetCompacityWeight(0.1);
    myHACD.SetVolumeWeight(0.0);

    printf("Hn");
    size_t nClusters = 2;       // minimum number of clusters
    size_t mVerts = 100;        // max of 100 vertices per convex-hull
    double concavity = 100;     // maximum concavity
    bool invert = false;
    bool addExtraDistPoints = false;
    bool addNeighboursDistPoints = false;
    bool addFacesPoints = false;

    printf("In");
    myHACD.SetNClusters(nClusters);
    myHACD.SetNVerticesPerCH(mVerts);
    myHACD.SetConcavity(concavity);
    myHACD.SetAddExtraDistPoints(addExtraDistPoints);
    myHACD.SetAddNeighboursDistPoints(addNeighboursDistPoints);
    myHACD.SetAddFacesPoints(addFacesPoints);

    printf("Jn");
    myHACD.Compute();

    printf("Kn");
    btCompoundShape* Compound = new btCompoundShape();

    printf("Ln");
    btTransform Trans;
    Trans.setIdentity();

    for (unsigned int c = 0; c < nClusters; c++)
    {
        size_t nPoints = myHACD.GetNPointsCH(c);
        size_t nTriangles = myHACD.GetNTrianglesCH(c);

        float* Vertices = new float[nPoints * 3];
        unsigned int* Triangles = new unsigned int[nTriangles * 3];

        HACD::Vec3<HACD::Real>* PointsCH = new HACD::Vec3<HACD::Real>[nPoints];
        HACD::Vec3<long>* TrianglesCH = new HACD::Vec3<long>[nTriangles];
        myHACD.GetCH(c, PointsCH, TrianglesCH);

        for (size_t v = 0; v < nPoints; v++)
        {
            Vertices[3 * v] = PointsCH[v].X();
            Vertices[3 * v + 1] = PointsCH[v].Y();
            Vertices[3 * v + 2] = PointsCH[v].Z();
        }
        for (size_t f = 0; f < nTriangles; f++)
        {
            Triangles[3 * f] = TrianglesCH[f].X();
            Triangles[3 * f + 1] = TrianglesCH[f].Y();
            Triangles[3 * f + 2] = TrianglesCH[f].Z();
        }

        delete[] PointsCH;
        delete[] TrianglesCH;

        //
        //  Create the individual pieces of the btCompoundShape
        //

        btTriangleMesh* TriMesh = new btTriangleMesh();
        m_trimeshes.push_back(TriMesh);

        btVector3 localScaling(6.0F, 6.0F, 6.0F);
        Centroid.setValue(0, 0, 0);

        btAlignedObjectArray<btVector3> h_Vertices;

        //  Might be nPoints*3
        for (unsigned int i = 0; i < nPoints; i++)
        {
            btVector3 Vertex(Vertices[i * 3], Vertices[i * 3 + 1], Vertices[i * 3 + 2]);
            Vertex *= localScaling;
            Centroid += Vertex;
        }

        //  Might be nPoints*3
        Centroid *= 1.0F / (float(nPoints));

        //  Might be nPoints*3
        for (unsigned int i = 0; i < nPoints; i++)
        {
            btVector3 Vertex(Vertices[i * 3], Vertices[i * 3 + 1], Vertices[i * 3 + 2]);
            Vertex *= localScaling;
            Centroid -= Vertex;
            h_Vertices.push_back(Vertex);
        }

        for (unsigned int i = 0; i < nTriangles; i++)
        {
            unsigned int index0 = *Triangles++;
            unsigned int index1 = *Triangles++;
            unsigned int index2 = *Triangles++;

            btVector3 vertex0(Vertices[index0 * 3], Vertices[index0 * 3 + 1], Vertices[index0 * 3 + 2]);
            btVector3 vertex1(Vertices[index1 * 3], Vertices[index1 * 3 + 1], Vertices[index1 * 3 + 2]);
            btVector3 vertex2(Vertices[index2 * 3], Vertices[index2 * 3 + 1], Vertices[index2 * 3 + 2]);
            vertex0 *= localScaling;
            vertex1 *= localScaling;
            vertex2 *= localScaling;

            vertex0 -= Centroid;
            vertex1 -= Centroid;
            vertex2 -= Centroid;

            TriMesh->addTriangle(vertex0, vertex1, vertex2);

            index0 += mBaseCount;
            index1 += mBaseCount;
            index2 += mBaseCount;
        }

        btConvexHullShape* ConvexShape = new btConvexHullShape(&(h_Vertices[0].getX()), h_Vertices.size());
        ConvexShape->setMargin(0.01F);
        m_convexShapes.push_back(ConvexShape);
        m_convexCentroids.push_back(Centroid);
        mBaseCount += nPoints;
    }

    for (unsigned int i = 0; i < m_convexShapes.size(); i++)
    {
        Trans.setOrigin(m_convexCentroids[i]);
        Compound->addChildShape(Trans, m_convexShapes[i]);
    }

    return Compound;
}