MercuryMesh.cpp

Go to the documentation of this file.

#include "MercuryMesh.h"
#include "MercuryUtil.h"
#include "MercuryDisplay.h"
#include "MercuryPoly.h"
#include "MercuryMath.h"
#include "MercuryLog.h"

MercuryMeshManager MESHMAN;

MercuryMeshCore::MercuryMeshCore()
{
    m_iMeshCount = 0;
    m_drawType = MGL_INVALID;

    m_useVBOs = false;
    m_verticesVBO = MVPtr(NULL);
    m_tangentVBO = MVPtr(NULL);
    m_binormalVBO = MVPtr(NULL);
    m_indicesVBO = MVPtr(NULL);
    m_extrasVBO = MVPtr(NULL);
    m_VBOinited = false;
}

bool MercuryMeshManager::RegMesh( MercuryMesh * pOut, const MString & sName, bool bCanCache )
{
    if( !bCanCache )
    {
        pOut->SetName( sName );
        pOut->core = new MercuryMeshCore;
        pOut->Init();
        pOut->core->m_iMeshCount = 1;
        return false;
    }

    MercuryMeshCore ** m = m_hAllMeshes.get(sName);

    //We already have one sitting aroudn
    if( m )
    {
        pOut->SetName( sName );
        pOut->Init();
        pOut->core = (*m);
        pOut->core->m_iMeshCount++;
        return true;
    }

    //Otherwise, we have to make it
    pOut->SetName( sName );
    m_hAllMeshes[sName] = pOut->core = new MercuryMeshCore;
    pOut->Init();
    pOut->core->m_iMeshCount = 1;
    return false;
}

void MercuryMeshManager::UnregMesh( MercuryMesh * pIn )
{
    pIn->core->m_iMeshCount--;
    if( pIn->core->m_iMeshCount <= 0 )
    {
        DISPLAY->DestroyVBO(*pIn);

        if( m_hAllMeshes.get( pIn->GetName() ) )
            m_hAllMeshes.remove( pIn->GetName() );
        SAFE_DELETE( pIn->core );
        return;
    }
}


MercuryMesh::MercuryMesh()
:MercuryObject()
{
    m_glState.Disable(MGLS_ALL);
    m_glState.Enable(MGLS_DEPTHWRITE | MGLS_DEPTHTEST | MGLS_COLORWRITE | MGLS_VERTEXARRAY |
                    MGLS_NORMALARRAY | MGLS_UVARRAY | MGLS_TEXTURING | MGLS_LIGHTING | MGLS_BLEND |
                    MGLS_SHADER | MGLS_OPAQUE );
}

MercuryMesh::~MercuryMesh()
{
    MESHMAN.UnregMesh(this);
}

void MercuryMesh::Init()
{
    MercuryObject::Init();
    m_drawable = true;
}

void MercuryMesh::Draw() 
{
    if (core->m_drawType == MGL_INVALID)
        return;

    ASSERT(!GetName().empty());
  
    DISPLAY->SendMatrixData(GetFinalMatrix());

//  if (core->m_VBOinited)
//      DISPLAY->DrawMeshVBO(*this);
//  else
        DISPLAY->DrawMesh(*this);
}

void MercuryMesh::BuildVBO()
{
    if (core->m_useVBOs && !core->m_VBOinited)
    {
        DISPLAY->GenerateVBO(*this);
        core->m_VBOinited = true;
    }
}

void MercuryMeshCore::CalculateVertexNormals()
{
    unsigned i;
    MVector <float> numFacePerVert;
    numFacePerVert.resize(m_vertices.size());

    for( i = 0; i < m_vertices.size(); ++i )
    {
        numFacePerVert[i] = 0;
        m_vertices[i].m_normal.Clear();
    }

    if (m_drawType == MGL_TRIANGLE)
        for( i = 0; i < m_indices.size(); i+=3 )
        {
            MercuryPoint pThisNormal = ( m_vertices[m_indices[i]].GetPointHandle() -
                    m_vertices[m_indices[i+1]].GetPointHandle() ).CrossProduct(
                    m_vertices[m_indices[i]].GetPointHandle() -
                    m_vertices[m_indices[i+2]].GetPointHandle());

            m_vertices[m_indices[i]].m_normal += pThisNormal;
            m_vertices[m_indices[i+1]].m_normal += pThisNormal;
            m_vertices[m_indices[i+2]].m_normal += pThisNormal;

            ++numFacePerVert[m_indices[i]];
            ++numFacePerVert[m_indices[i+1]];
            ++numFacePerVert[m_indices[i+2]];
        }

    for( i = 0; i < m_vertices.size(); ++i )
    {
        m_vertices[i].m_normal /= numFacePerVert[i];
        m_vertices[i].m_normal.NormalizeSelf();
    }

    ComputeBinormalsAndTangents();
}


//This function takes a 3-high, 3-wide, matrix, in the form:
// [0] [1] [2] [3]
// [4] [5] [6] [7]
// [8] [9][10][11]
//
// and solves it so it has the form:
//  1   0   0   A
//  0   1   0   B
//  0   0   1   C
//
// This can be used in more general cases, but isn't ready for MercuryMathing

inline void RowAddEqualScalar( float * r1s, float * r2, float scalar )
{ r1s[0] += r2[0] * scalar; r1s[1] += r2[1] * scalar; r1s[2] += r2[2] * scalar; r1s[3] += r2[3] * scalar; }

inline void RowScale( float * r1s, float scalar )
{ r1s[0] *= scalar; r1s[1] *= scalar; r1s[2] *= scalar; r1s[3] *= scalar; }

void SolveThreeByFour( float * mat )
{
    //Step 1, prevent inaccuracies by adding various rows to each other to make the matrix
    //  have bigger numbers to start with
    if( ABS( mat[0] ) < 0.001f )
        if( ABS( mat[4] ) > ABS( mat[8] ) )
            RowAddEqualScalar( &mat[0], &mat[4], 1 );
        else
            RowAddEqualScalar( &mat[0], &mat[8], 1 );

    //Now that our matrix has nice values, we can solve it.
    RowScale( &mat[0], 1.f/mat[0] );
    RowAddEqualScalar( &mat[4], &mat[0], -mat[4]/mat[0] );
    RowAddEqualScalar( &mat[8], &mat[0], -mat[8]/mat[0] );

    if( ABS( mat[5] ) < 0.001f )
        if( ABS( mat[1] ) > ABS( mat[9] ) )
            RowAddEqualScalar( &mat[4], &mat[0], 1 );
        else
            RowAddEqualScalar( &mat[4], &mat[8], 1 );

    RowScale( &mat[4], 1.f/mat[5] );
    RowAddEqualScalar( &mat[0], &mat[4], -mat[1]/mat[5] );
    RowAddEqualScalar( &mat[8], &mat[4], -mat[9]/mat[5] );

    if( ABS( mat[10] ) < 0.001f )
        if( ABS( mat[2] ) > ABS( mat[6] ) )
            RowAddEqualScalar( &mat[8], &mat[0], 1 );
        else
            RowAddEqualScalar( &mat[8], &mat[4], 1 );

    RowScale( &mat[8], 1.f/mat[10] );
    RowAddEqualScalar( &mat[0], &mat[8], -mat[2]/mat[10] );
    RowAddEqualScalar( &mat[4], &mat[8], -mat[6]/mat[10] );

    //verify here that we're solved
    return;
}

void MercuryMeshCore::ComputeBinormalsAndTangents()
{
    if (m_indices.size() <= 0)
        return;

    unsigned int * ints = &m_indices[0];

    m_tangents.resize( m_vertices.size() );
    m_binormals.resize( m_vertices.size() );

    unsigned i;

    for( i = 0; i < m_indices.size(); i+=3 )
    {
        unsigned int ind[3];
        ind[0] = ints[i+0];
        ind[1] = ints[i+1];
        ind[2] = ints[i+2];

        float uv[3][2];
        MercuryPoint p[3];
        p[0] = m_vertices[ind[0]].GetPointHandle();
        p[1] = m_vertices[ind[1]].GetPointHandle();
        p[2] = m_vertices[ind[2]].GetPointHandle();
        m_vertices[ind[0]].GetUV( uv[0] );
        m_vertices[ind[1]].GetUV( uv[1] );
        m_vertices[ind[2]].GetUV( uv[2] );

        MercuryPoint pLocalNormal;
        pLocalNormal = (p[0] - p[1]).CrossProduct( p[2] - p[1] );
        pLocalNormal.NormalizeSelf();

        bool bSubZForX = false;
        bool bSubZForY = false;

        if( ABS( pLocalNormal.z ) < 0.001f )
        {
            if( ABS( pLocalNormal.y ) < 0.001f )
                bSubZForX = true;
            else
                bSubZForY = true;
        }

        float fMatToSolve[12];
        fMatToSolve[ 0] = (!bSubZForX)?p[0].x:p[0].z;
        fMatToSolve[ 1] = (!bSubZForY)?p[0].y:p[0].z;
        fMatToSolve[ 2] = uv[0][1];
        fMatToSolve[ 3] = 1;
        fMatToSolve[ 4] = (!bSubZForX)?p[1].x:p[1].z;
        fMatToSolve[ 5] = (!bSubZForY)?p[1].y:p[1].z;
        fMatToSolve[ 6] = uv[1][1];
        fMatToSolve[ 7] = 1;
        fMatToSolve[ 8] = (!bSubZForX)?p[2].x:p[2].z;
        fMatToSolve[ 9] = (!bSubZForY)?p[2].y:p[2].z;
        fMatToSolve[10] = uv[2][1];
        fMatToSolve[11] = 1;

        SolveThreeByFour( fMatToSolve );
        
        float xComp = fMatToSolve[3];
        float yComp = fMatToSolve[7];
        float cComp = fMatToSolve[11];

        MercuryPoint pBiNormal;
        if( bSubZForX )
        {
            pBiNormal.x = 0;
            pBiNormal.y = yComp;
            pBiNormal.z = xComp;
        } else if( bSubZForY )
        {
            pBiNormal.x = xComp;
            pBiNormal.y = 0;
            pBiNormal.z = yComp;
        }
        else
        {
            pBiNormal.x = xComp;
            pBiNormal.y = yComp;
            pBiNormal.z = 0;
        }

        MercuryPoint pTangent = (pBiNormal.CrossProduct( pLocalNormal )).Normalize();

        pBiNormal = (pTangent.CrossProduct( pLocalNormal)).Normalize();

        m_tangents[ind[0]] += pTangent;
        m_tangents[ind[1]] += pTangent;
        m_tangents[ind[2]] += pTangent;

        m_binormals[ind[0]] += pBiNormal;
        m_binormals[ind[1]] += pBiNormal;
        m_binormals[ind[2]] += pBiNormal;
    }

    //Now, we have all local BiNormals and Tangents.  Let's weight and set them all
    for( i = 0; i < m_tangents.size(); ++i )
    {
        m_tangents[i].NormalizeSelf();
        m_binormals[i].NormalizeSelf();
    //  m_vertices[i].m_normal = -1 * m_binormals[i];
    }

}

/* 
 * Copyright (c) 2006 Joshua Allen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by