source: GTP/trunk/Lib/Vis/OnlineCullingCHC/IVReader/src/ivmanualmeshloader.cpp @ 1139

#include "ivmanualmeshloader.h"
#include "ivreader.h"

IVManualMeshLoader::IVManualMeshLoader()
{
        data = NULL;
}


IVManualMeshLoader::IVManualMeshLoader(IVMeshData *mData)
{
        data = mData;
/*      data = new IVMeshData();
        if ((mData->indices != NULL) && (mData->icnt > 0))
        {
                data->icnt = mData->icnt;
                data->indices = new Ogre::Real[mData->icnt];
                memcpy(data->indices, mData->indices, mData->icnt*sizeof(Ogre::Real));
        }
        if ((mData->vertices != NULL) && (mData->vcnt > 0))
        {
                data->vcnt = mData->vcnt;
                data->vertices = new Ogre::Real[mData->vcnt];
                memcpy(data->vertices, mData->vertices, mData->vcnt*sizeof(Ogre::Real));
        }
        if ((mData->normals != NULL) && (mData->vcnt > 0))
        {
                data->ncnt = mData->ncnt;
                data->normals = new Ogre::Real[mData->ncnt];
                memcpy(data->normals, mData->normals, mData->ncnt*sizeof(Ogre::Real));
        }
        if ((mData->texCoords != NULL) && (mData->tcnt > 0))
        {
                data->tcnt = mData->tcnt;
                data->texCoords = new Ogre::Real[mData->tcnt];
                memcpy(data->texCoords, mData->texCoords, mData->tcnt*sizeof(Ogre::Real));
        }
        */
}

IVManualMeshLoader::~IVManualMeshLoader()
{
/*      if (data != NULL)
        {
                if (data->vertices != NULL)             delete [] data->vertices;
                if (data->normals != NULL)              delete [] data->normals;
                if (data->texCoords != NULL)    delete [] data->texCoords;
                if (data->indices != NULL)              delete [] data->indices;
                delete data;
        }
        */
        if (data != NULL)
        {
                data->collapse();
                delete data;
        }
}


Ogre::AxisAlignedBox *IVManualMeshLoader::getBoundingBox()
{
        return data->boundingBox;
}


void IVManualMeshLoader::loadResource(Ogre::Resource *resource)
{
        using namespace Ogre;
        Mesh *pMesh = (Mesh *) resource;


        Vector3 translation = data->boundingBox->getCenter();

        bool nOk = ((data->normals != NULL) && (data->ncnt > 0));
        bool tOk = ((data->texCoords != NULL) && (data->tcnt > 0));
        
        pMesh->sharedVertexData = new VertexData(); 

        VertexDeclaration* vertexDecl = pMesh->sharedVertexData->vertexDeclaration; 

        size_t currOffset = 0; 
        vertexDecl->addElement(0, currOffset, VET_FLOAT3, VES_POSITION); 
        currOffset += VertexElement::getTypeSize(VET_FLOAT3); 
        if (nOk)
        {
                vertexDecl->addElement(0, currOffset, VET_FLOAT3, VES_NORMAL); 
                currOffset += VertexElement::getTypeSize(VET_FLOAT3); 
        }
    if (tOk)
        {
                vertexDecl->addElement(0, currOffset, VET_FLOAT2, VES_TEXTURE_COORDINATES); 
                currOffset += VertexElement::getTypeSize(VET_FLOAT2); 
        }

        pMesh->sharedVertexData->vertexCount = data->vcnt/3; 
        HardwareVertexBufferSharedPtr vbuf = 
                HardwareBufferManager::getSingleton(). 
                createVertexBuffer(vertexDecl->getVertexSize(0), pMesh->sharedVertexData->vertexCount, 
                        HardwareBuffer::HBU_STATIC_WRITE_ONLY, false); 

        VertexBufferBinding* binding = pMesh->sharedVertexData->vertexBufferBinding; 
        binding->setBinding(0, vbuf); 

        Real* pVertices = static_cast<Real*>(vbuf->lock(HardwareBuffer::HBL_DISCARD)); 

        int offset = 0, size = 3;
        if (nOk) size += 3;
        if (tOk) size += 2;
        for (int i=0; i<data->vcnt/3; i++) 
        {
                pVertices[i*size]   = data->vertices[i*3]   - translation.x;
                pVertices[i*size+1] = data->vertices[i*3+1] - translation.y;
                pVertices[i*size+2] = data->vertices[i*3+2] - translation.z;

                offset = 3;
                if (nOk)
                {
                        pVertices[i*size+offset] = data->normals[i*3];   offset++;
                        pVertices[i*size+offset] = data->normals[i*3+1]; offset++;
                        pVertices[i*size+offset] = data->normals[i*3+2]; offset++;
                }
                if (tOk)
                {
                        pVertices[i*size+offset] = data->texCoords[i*2];   offset++;
                        pVertices[i*size+offset] = -data->texCoords[i*2+1]; offset++;
                }
        }

        vbuf->unlock(); 


        SubMesh *pSub = pMesh->createSubMesh(); 
        pSub->operationType = RenderOperation::OT_TRIANGLE_LIST; //;data->roType;
        pSub->useSharedVertices = true; 

        pSub->indexData->indexCount = data->icnt; 
        pSub->indexData->indexBuffer = HardwareBufferManager::getSingleton(). 
                createIndexBuffer(HardwareIndexBuffer::IT_16BIT, 
                        pSub->indexData->indexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY, false); 

        HardwareIndexBufferSharedPtr ibuf = pSub->indexData->indexBuffer; 
        unsigned short* pIndices = static_cast<unsigned short*>(ibuf->lock(HardwareBuffer::HBL_DISCARD)); 

        for (i = 0; i < data->icnt; i++) pIndices[i] = data->indices[i];
        
        ibuf->unlock(); 
                
        AxisAlignedBox bb(data->boundingBox->getMinimum() - translation, data->boundingBox->getMaximum() - translation);
        //AxisAlignedBox bb(data->boundingBox->getMinimum(), data->boundingBox->getMaximum());
        pMesh->_setBounds(bb); 
        Real radius = data->boundingBox->getMinimum().length();
        if (data->boundingBox->getMaximum().length() > radius) radius = data->boundingBox->getMaximum().length();
        pMesh->_setBoundingSphereRadius(radius); 

}