source: GTP/trunk/Lib/Vis/OnlineCullingCHC/ObjReader/src/ObjManualMeshLoader.cpp @ 2111

#include "ObjManualMeshLoader.h"
#include "ObjReader.h"

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


ObjManualMeshLoader::ObjManualMeshLoader(ObjMeshData *mData):
data(mData)
{
}


ObjManualMeshLoader::~ObjManualMeshLoader()
{
        if (data != NULL)
        {
                data->collapse();
                delete data;
        }
}


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


void ObjManualMeshLoader::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); 

}