source: GTP/branches/IllumWPdeliver2008dec/IlluminationWP/demos/Standalone/MultipleReflections [DirectX]/Mesh.cpp @ 3255

#include "dxstdafx.h"
#include "Mesh.h"

extern IDirect3DDevice9* g_pd3dDevice;

Mesh::Mesh(LPCWSTR fileName, LPCWSTR texFileName, float preferredDiameter, D3DXVECTOR3 offset)
{
        originalDiameter = 1;
        this->preferredDiameter = preferredDiameter;
        originalSize = D3DXVECTOR3(1,1,1); 
        position = D3DXVECTOR3(0,0,0); 
        containerSize = D3DXVECTOR3(1,1,1); 
        numMaterials = 0;
        pMesh = NULL;

        D3DXMatrixIdentity(&rotation);

        Load(fileName);
        Move(offset);
        pMeshTexture = NULL;

        V( D3DXCreateTextureFromFile(g_pd3dDevice, texFileName, &pMeshTexture) );
}

Mesh::~Mesh()
{
    SAFE_RELEASE( pMesh );
        SAFE_RELEASE( pMeshTexture );
}

void Mesh::Move(D3DXVECTOR3 offset, bool bContainerOnly /*= false*/) 
{
        position += offset;

        if ( bContainerOnly )   // keep some distance from the walls
        {
                D3DXVECTOR3 maxOffset = containerSize * 0.99f - GetMeshSize();
                D3DXVECTOR3 minOffset = -maxOffset;

                if (position.x > maxOffset.x) position.x = maxOffset.x;
                if (position.y > maxOffset.y) position.y = maxOffset.y;
                if (position.z > maxOffset.z) position.z = maxOffset.z;

                if (position.x < minOffset.x) position.x = minOffset.x;
                if (position.y < minOffset.y) position.y = minOffset.y;
                if (position.z < minOffset.z) position.z = minOffset.z;
        }
}

HRESULT Mesh::CalculateMeshSize( )
{
        // default size
        originalSize = D3DXVECTOR3(1,1,1); 
        originalDiameter = 1;

        IDirect3DVertexBuffer9* pMeshVB = NULL;
        D3DXVECTOR3 minPos, maxPos;
        BYTE* pVertices;

        // Lock the vertex buffer to generate a simple bounding box

        hr = pMesh->GetVertexBuffer( &pMeshVB );
        if( SUCCEEDED( hr ) )
        {
                hr = pMeshVB->Lock( 0, 0, (void**)&pVertices, D3DLOCK_NOSYSLOCK );
                if( SUCCEEDED(hr) )
                {
                        V( D3DXComputeBoundingBox( ( D3DXVECTOR3*)pVertices, pMesh->GetNumVertices(),
                                                                        D3DXGetFVFVertexSize( pMesh->GetFVF() ),
                                                                        &minPos, &maxPos ) );

                        D3DXVECTOR3 vCenter = ( minPos + maxPos ) / 2.0f;

                        // eliminating offset from the mesh

                        DWORD numVerts = pMesh->GetNumVertices();                                       // get the face count
                        DWORD vertSize = D3DXGetFVFVertexSize(pMesh->GetFVF());         // calculate vertex size

                        for (DWORD i = 0; i < numVerts; i++)                                            // loop through the vertices
                        {
                                D3DXVECTOR3 *vPtr=(D3DXVECTOR3*)pVertices;                              
                                *vPtr -= vCenter;                                                                               // eliminating offset
                                pVertices += vertSize;                                                                  // set pointer to next vertex
                        }

                        pMeshVB->Unlock();
                        pMeshVB->Release();

                        // size of the object
                        originalSize = ( maxPos - minPos ) / 2.0f;
                        // object "diameter" is calculated from the size of the bounding box only
                        originalDiameter = sqrt( originalSize.x * originalSize.x + 
                                                                         originalSize.y * originalSize.y +
                                                                         originalSize.z * originalSize.z) / 1.732f;
                }
        }
        
        return hr;
}

void Mesh::Load( LPCWSTR fileName )
{  
        SAFE_RELEASE( pMesh );
    pMesh = NULL;

    HRESULT hr;

    if (FAILED( D3DXLoadMeshFromX(fileName, D3DXMESH_MANAGED, g_pd3dDevice, NULL, NULL, NULL, &numMaterials, &pMesh) ))
        {
                MessageBox(NULL, L"Media not found!", fileName, MB_ICONEXCLAMATION);
                exit(-1);
        }
        
//      D3DXSaveMeshToX(L"cubenew.x",pMesh,NULL,NULL,NULL,0,D3DXF_FILEFORMAT_BINARY);
        
        if ( FAILED( CalculateMeshSize() ))
        {
                MessageBox(NULL, L"Could not calculate bounding box!\nUsing original mesh size...",
                        fileName, MB_ICONEXCLAMATION);
        }

    DWORD *rgdwAdjacency = NULL;

    // Make sure there are normals which are required for lighting
    if( !(pMesh->GetFVF() & D3DFVF_NORMAL) )
    {
        ID3DXMesh* pTempMesh;
        V( pMesh->CloneMeshFVF( pMesh->GetOptions(), 
                                  pMesh->GetFVF() | D3DFVF_NORMAL, 
                                  g_pd3dDevice, &pTempMesh ) );
        V( D3DXComputeNormals( pTempMesh, NULL ) );

        SAFE_RELEASE( pMesh );
        pMesh = pTempMesh;
    }

    // Optimize the mesh for this graphics card's vertex cache 
    rgdwAdjacency = new DWORD[pMesh->GetNumFaces() * 3];
    if( rgdwAdjacency == NULL ) return /*E_OUTOFMEMORY*/;

    V( pMesh->ConvertPointRepsToAdjacency(NULL, rgdwAdjacency) );
    V( pMesh->OptimizeInplace(D3DXMESHOPT_VERTEXCACHE, rgdwAdjacency, NULL, NULL, NULL) );
    delete[] rgdwAdjacency;
}

HRESULT Mesh::Draw()
{
        HRESULT hr;
    // Set and draw each of the materials in the mesh
    for( DWORD iMaterial = 0; iMaterial < numMaterials; iMaterial++ )
    {
        V( pMesh->DrawSubset( iMaterial ) );
    }

    return S_OK;
}