vrsode/src/TriangleData.cpp

Go to the documentation of this file.

#include "TriangleData.h"
#include "TrimeshShape.h"

namespace vrsode
{

TriangleData::TriangleData(unsigned int p_vCount, unsigned int p_iCount)
{
    m_activeDataPool = 1;

    m_callbackFunction = 0;
    m_callbackShape = 0;
    
    m_vertexArraySize[0] = p_vCount * 3;
    m_vertexArraySize[1] = 0;

    m_indexArraySize[0] = p_iCount;
    m_indexArraySize[1] = 0;
    
    m_vertexArrayFill[0] = 0;
    m_vertexArrayFill[1] = 0;
    
    m_indexArrayFill[0] = 0;
    m_indexArrayFill[1] = 0;
    
    m_vertexArray[0] = (VO_TRIMESH_COORD_TYPE*)
        malloc(sizeof(VO_TRIMESH_COORD_TYPE) * m_vertexArraySize[0]);
    assert(m_vertexArray[0]);

    m_indexArray[0] = (VO_TRIMESH_INDEX_TYPE*)
        malloc(sizeof(VO_TRIMESH_INDEX_TYPE) * m_indexArraySize[0]);
    assert(m_indexArray[0]);

    m_vertexArray[1] = 0;
    m_indexArray[1] = 0;
}

TriangleData::~TriangleData()
{
    free(m_vertexArray[m_activeDataPool]);
    free(m_indexArray[m_activeDataPool]);
}

void
TriangleData::addVertex(VRS::Vector3Base<VO_TRIMESH_COORD_TYPE> p_vertex)
{
    addVertex(p_vertex[0], p_vertex[1], p_vertex[2]);
}

void
TriangleData::addVertex(VO_TRIMESH_COORD_TYPE p_x, 
                        VO_TRIMESH_COORD_TYPE p_y, 
                        VO_TRIMESH_COORD_TYPE p_z)
{
    assert(m_vertexArrayFill[!m_activeDataPool] + 3 
            <= m_vertexArraySize[!m_activeDataPool]);
    
    m_vertexArray[!m_activeDataPool]
        [m_vertexArrayFill[!m_activeDataPool]++] = p_x;
    m_vertexArray[!m_activeDataPool]
        [m_vertexArrayFill[!m_activeDataPool]++] = p_y;
    m_vertexArray[!m_activeDataPool]
        [m_vertexArrayFill[!m_activeDataPool]++] = p_z;
}

void
TriangleData::addIndex(VRS::Vector3Base<VO_TRIMESH_INDEX_TYPE> p_index)
{
    addIndex(p_index[0], p_index[1], p_index[2]);
}

void
TriangleData::addIndex(VO_TRIMESH_INDEX_TYPE p_1, 
                        VO_TRIMESH_INDEX_TYPE p_2, 
                        VO_TRIMESH_INDEX_TYPE p_3)
{
    assert(m_indexArrayFill[!m_activeDataPool] + 3 
            <= m_indexArraySize[!m_activeDataPool]);
    
    m_indexArray[!m_activeDataPool]
        [m_indexArrayFill[!m_activeDataPool]++] = p_1;
    m_indexArray[!m_activeDataPool]
        [m_indexArrayFill[!m_activeDataPool]++] = p_2;
    m_indexArray[!m_activeDataPool]
        [m_indexArrayFill[!m_activeDataPool]++] = p_3;
}

void
TriangleData::addTriangle(VRS::Vector3Base<VO_TRIMESH_COORD_TYPE> p_1,
                            VRS::Vector3Base<VO_TRIMESH_COORD_TYPE> p_2, 
                            VRS::Vector3Base<VO_TRIMESH_COORD_TYPE> p_3)
{
    unsigned int firstIndex = m_vertexArrayFill[!m_activeDataPool] / 3;
    
    addVertex(p_1);
    addVertex(p_2);
    addVertex(p_3);
    
    addIndex(firstIndex, firstIndex + 1, firstIndex + 2);
}

void
TriangleData::addTriangle(VO_TRIMESH_COORD_TYPE p_11, 
                        VO_TRIMESH_COORD_TYPE p_12, VO_TRIMESH_COORD_TYPE p_13,
                          VO_TRIMESH_COORD_TYPE p_21, 
                        VO_TRIMESH_COORD_TYPE p_22, VO_TRIMESH_COORD_TYPE p_23,
                          VO_TRIMESH_COORD_TYPE p_31, 
                        VO_TRIMESH_COORD_TYPE p_32, VO_TRIMESH_COORD_TYPE p_33)
{
    addTriangle(
        VRS::Vector3Base<VO_TRIMESH_COORD_TYPE>(p_11, p_12, p_13),
        VRS::Vector3Base<VO_TRIMESH_COORD_TYPE>(p_21, p_22, p_23), 
        VRS::Vector3Base<VO_TRIMESH_COORD_TYPE>(p_31, p_32, p_33));
}

void
TriangleData::addQuad(VRS::Vector3Base<VO_TRIMESH_COORD_TYPE> p_1,
                        VRS::Vector3Base<VO_TRIMESH_COORD_TYPE> p_2,
                        VRS::Vector3Base<VO_TRIMESH_COORD_TYPE> p_3,
                        VRS::Vector3Base<VO_TRIMESH_COORD_TYPE> p_4)
{
    // FIXME: share vertices
    addTriangle(p_1, p_2, p_3);
    addTriangle(p_1, p_3, p_4);
}

void
TriangleData::addQuad(VO_TRIMESH_COORD_TYPE p_11, VO_TRIMESH_COORD_TYPE p_12, 
                        VO_TRIMESH_COORD_TYPE p_13, 
                        VO_TRIMESH_COORD_TYPE p_21, VO_TRIMESH_COORD_TYPE p_22,
                        VO_TRIMESH_COORD_TYPE p_23, 
                        VO_TRIMESH_COORD_TYPE p_31, VO_TRIMESH_COORD_TYPE p_32,
                        VO_TRIMESH_COORD_TYPE p_33, 
                        VO_TRIMESH_COORD_TYPE p_41, VO_TRIMESH_COORD_TYPE p_42,
                        VO_TRIMESH_COORD_TYPE p_43)
{
    // FIXME: use delegation here or above
    addTriangle(p_11, p_12, p_13, p_21, p_22, p_23, p_31, p_32, p_33);
    addTriangle(p_11, p_12, p_13, p_31, p_32, p_33, p_41, p_42, p_43);
}

VO_TRIMESH_COORD_TYPE*
TriangleData::vertexArray()
{
    return m_vertexArray[m_activeDataPool];
}

VO_TRIMESH_INDEX_TYPE*
TriangleData::indexArray()
{
    return m_indexArray[m_activeDataPool];
}

unsigned int
TriangleData::vertexCount() const
{
    return m_vertexArrayFill[m_activeDataPool] / 3;
}

unsigned int
TriangleData::indexCount() const
{
    return m_indexArrayFill[m_activeDataPool];
}

unsigned int
TriangleData::triangleCount() const
{
    return m_indexArrayFill[m_activeDataPool] / 3;
}


const std::vector<VRS::Vector3Base<double> >
TriangleData::explicitVertexList() const
{
    std::vector<VRS::Vector3Base<double> > pureVertexList;

    for(unsigned int index = 0; index < indexCount(); index++)
        pureVertexList.push_back(
            VRS::Vector3Base<double>(
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index] * 3 + 0],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index] * 3 + 1],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index] * 3 + 2]));

    return pureVertexList;
}

const std::vector<VRS::Vector3Base<double> >
TriangleData::explicitVertexListForLines() const
{
    std::vector<VRS::Vector3Base<double> > pureVertexList;

    for(unsigned int index = 0; index < indexCount(); index += 3)
    {
        pureVertexList.push_back(
            VRS::Vector3Base<double>(
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index] * 3 + 0],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index] * 3 + 1],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index] * 3 + 2]));
        pureVertexList.push_back(
            VRS::Vector3Base<double>(
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+1] * 3 + 0],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+1] * 3 + 1],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+1] * 3 + 2]));
        pureVertexList.push_back(
            VRS::Vector3Base<double>(
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index] * 3 + 0],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index] * 3 + 1],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index] * 3 + 2]));
        pureVertexList.push_back(
            VRS::Vector3Base<double>(
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+2] * 3 + 0],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+2] * 3 + 1],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+2] * 3 + 2]));
        pureVertexList.push_back(
            VRS::Vector3Base<double>(
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+1] * 3 + 0],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+1] * 3 + 1],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+1] * 3 + 2]));
        pureVertexList.push_back(
            VRS::Vector3Base<double>(
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+2] * 3 + 0],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+2] * 3 + 1],
                (double)m_vertexArray[m_activeDataPool]
                    [m_indexArray[m_activeDataPool][index+2] * 3 + 2]));
    }

    return pureVertexList;
}

unsigned int
TriangleData::sizeOfVertexStride()
{
    return 3 * sizeof(VO_TRIMESH_COORD_TYPE);
}

unsigned int
TriangleData::sizeOfTriangleStride()
{
    return 3 * sizeof(VO_TRIMESH_INDEX_TYPE);
}

void
TriangleData::setGeometryChangeCallback(VRS::SO<TrimeshShape> p_shape,
                                        void (TrimeshShape::*p_function)())
{
    m_callbackShape = p_shape;
    m_callbackFunction = p_function;
}

void
TriangleData::reportGeometryChange()
{
    if(m_callbackShape && m_callbackFunction)
        (m_callbackShape->*m_callbackFunction)();
}

void
TriangleData::initDataUpdate(unsigned int p_vCount, unsigned int p_iCount)
{
    cleanInactivePool();
    m_vertexArraySize[!m_activeDataPool] = p_vCount * 3;
    m_indexArraySize[!m_activeDataPool] = p_iCount;
    
    m_vertexArrayFill[!m_activeDataPool] = 0;
    m_indexArrayFill[!m_activeDataPool] = 0;
    
    m_vertexArray[!m_activeDataPool] = (VO_TRIMESH_COORD_TYPE*)
        malloc(sizeof(VO_TRIMESH_COORD_TYPE) *
                m_vertexArraySize[!m_activeDataPool]);
    assert(m_vertexArray[!m_activeDataPool]);

    m_indexArray[!m_activeDataPool] = (VO_TRIMESH_INDEX_TYPE*)
        malloc(sizeof(VO_TRIMESH_INDEX_TYPE) *
                m_indexArraySize[!m_activeDataPool]);
    assert(m_indexArray[!m_activeDataPool]);    
}

void
TriangleData::initDataUpdateKeepCurrent()
{
    initDataUpdate(m_vertexArraySize[m_activeDataPool] / 3,
                    m_indexArraySize[m_activeDataPool]);

    memcpy(m_vertexArray[!m_activeDataPool], 
            m_vertexArray[m_activeDataPool],
            m_vertexArraySize[m_activeDataPool] * 
            sizeof(VO_TRIMESH_COORD_TYPE));

    memcpy(m_indexArray[!m_activeDataPool], 
            m_indexArray[m_activeDataPool],
            m_indexArraySize[m_activeDataPool] * 
            sizeof(VO_TRIMESH_INDEX_TYPE));

    m_vertexArrayFill[!m_activeDataPool] = m_vertexArrayFill[m_activeDataPool];
    m_indexArrayFill[!m_activeDataPool]  = m_indexArrayFill[m_activeDataPool];
}

void
TriangleData::cleanInactivePool()
{
    if(m_vertexArray[!m_activeDataPool])
        free(m_vertexArray[!m_activeDataPool]);

    if(m_indexArray[!m_activeDataPool])
        free(m_indexArray[!m_activeDataPool]);
    
    m_vertexArray[!m_activeDataPool]     = 0;
    m_indexArray[!m_activeDataPool]      = 0;
    m_vertexArraySize[!m_activeDataPool] = 0;
    m_indexArraySize[!m_activeDataPool]  = 0;
    m_vertexArrayFill[!m_activeDataPool] = 0;
    m_indexArrayFill[!m_activeDataPool]  = 0;
}

void
TriangleData::rollbackDataUpdate()
{
    cleanInactivePool();
}

void
TriangleData::commitDataUpdate()
{
    m_activeDataPool = !m_activeDataPool;
    reportGeometryChange();
    cleanInactivePool();
}

VO_TRIMESH_COORD_TYPE*
TriangleData::uncommittedVertexArray()
{   
    return m_vertexArray[!m_activeDataPool];
}

VO_TRIMESH_INDEX_TYPE*
TriangleData::uncommittedIndexArray()
{   
    return m_indexArray[!m_activeDataPool];
}

void
TriangleData::dump()
{
    std::cout << "Vertex Array Dump for TriangleData " << this << std::endl;

    for(unsigned int i = 0; i < vertexCount() * 3; i += 3)
        std::cout << "Vertex " << i / 3 << ": " 
            << m_vertexArray[m_activeDataPool][i+0] << " "
            << m_vertexArray[m_activeDataPool][i+1] << " "
            << m_vertexArray[m_activeDataPool][i+2] << " " << std::endl;
    
    std::cout << std::endl;
}

void
TriangleData::createDebugCube()
{
    // 8 vertices
    addVertex(-1, -1, -1);
    addVertex(-1, -1,  1);
    addVertex(-1,  1, -1);
    addVertex(-1,  1,  1);
    addVertex( 1, -1, -1);
    addVertex( 1, -1,  1);
    addVertex( 1,  1, -1);
    addVertex( 1,  1,  1);

    // 12 triangles
    addIndex(0, 1, 2);
    addIndex(1, 2, 3);
    addIndex(4, 5, 6);
    addIndex(5, 6, 7);
    addIndex(1, 3, 5);
    addIndex(3, 5, 7);
    addIndex(0, 2, 4);
    addIndex(2, 4, 6);
    addIndex(0, 1, 4);
    addIndex(1, 4, 5);
    addIndex(2, 3, 6);
    addIndex(3, 6, 7);
}

void
TriangleData::createDebugThing()
{
    addVertex(-3,-3,-3);
    addVertex( 0, 0, 3);
    addVertex( 0, 3, 3);
    addVertex( 3, 3, 3);
    addVertex( 0, 0,-3);
    addVertex( 0,-3,-3);
    addVertex( 0, 0, 0);
    
    addIndex(6,1,2);
    addIndex(1,2,3);
    addIndex(6,1,3);
    addIndex(6,2,3);
    addIndex(6,4,5);
    addIndex(4,5,0);
    addIndex(6,4,0);
    addIndex(6,5,0);
}

void
TriangleData::setIndexArrayFill(unsigned int p_fill)
{
    m_indexArrayFill[!m_activeDataPool] = p_fill;
}

void
TriangleData::setVertexArrayFill(unsigned int p_fill)
{
    m_vertexArrayFill[!m_activeDataPool] = p_fill * 3;
}

}

---