mgcgptrimesh.cpp

《3D游戏引擎设计》的源码

// Magic Software, Inc.
// http://www.magic-software.com
// Copyright (c) 2000, All Rights Reserved
//
// Source code from Magic Software is supplied under the terms of a license
// agreement and may not be copied or disclosed except in accordance with the
// terms of that agreement.  The various license agreements may be found at
// the Magic Software web site.  This file is subject to the license
//
// RESTRICTED USE SOURCE CODE
// http://www.magic-software.com/License/restricted.pdf

#include "MgcGPRenderer.h"
#include "MgcGPTriMesh.h"

unsigned int MgcGPTriMesh::ms_uiVertexGrowBy = 8;
unsigned int MgcGPTriMesh::ms_uiEdgeGrowBy = 8;
unsigned int MgcGPTriMesh::ms_uiTriangleGrowBy = 8;

MgcImplementRTTI(MgcGPTriMesh,MgcGeometry);
MgcImplementStream(MgcGPTriMesh);

//---------------------------------------------------------------------------
MgcGPTriMesh::MgcGPTriMesh (unsigned int uiVertexQuantity,
    MgcVector3* akVertex, MgcVector3* akNormal, MgcColor* akColor,
    MgcVector2* akTexture, unsigned int uiTriangleQuantity,
    unsigned int uiEdgeQuantity)
    :
    m_akVertex(akVertex),
    m_akNormal(akNormal),
    m_akColor(akColor),
    m_akTexture(akTexture),
    m_akEdge(uiEdgeQuantity),
    m_akTriangle(uiTriangleQuantity),
    m_akFacetPlane(uiTriangleQuantity)
{
    assert( uiVertexQuantity >= 3 && akVertex );

    m_uiVertexQuantity = uiVertexQuantity;
    m_uiVerticesUsed = uiVertexQuantity;
    m_uiEdgeQuantity = uiEdgeQuantity;
    m_uiEdgesUsed = 0;
    m_uiTriangleQuantity = uiTriangleQuantity;
    m_uiTrianglesUsed = 0;

    m_bHasNormals = ( m_akNormal.GetStorage() != 0 );
    m_bHasColors = ( m_akColor.GetStorage() != 0 );
    m_bHasTextures = ( m_akTexture.GetStorage() != 0 );
}
//---------------------------------------------------------------------------
MgcGPTriMesh::MgcGPTriMesh ()
{
    m_uiVertexQuantity = 0;
    m_uiVerticesUsed = 0;
    m_uiEdgeQuantity = 0;
    m_uiEdgesUsed = 0;
    m_uiTriangleQuantity = 0;
    m_uiTrianglesUsed = 0;
    m_bHasNormals = false;
    m_bHasColors = false;
    m_bHasTextures = false;
}
//---------------------------------------------------------------------------
MgcGPTriMesh::~MgcGPTriMesh ()
{
}
//---------------------------------------------------------------------------
unsigned int MgcGPTriMesh::AddEdge (unsigned int uiV0, unsigned int uiV1,
    unsigned int uiT)
{
    // arrange for edges to store vertices in increasing order
    bool bSwap = false;
    if ( uiV0 > uiV1 )
    {
        unsigned int uiSave = uiV0;
        uiV0 = uiV1;
        uiV1 = uiSave;
        bSwap = true;
    }

    // search for edge
    unsigned uiE;
    for (uiE = 0; uiE < m_uiEdgesUsed; uiE++)
    {
        EdgeRecord& edge = m_akEdge[uiE];
        if ( uiV0 == edge.Vertex(0) && uiV1 == edge.Vertex(1) )
        {
            // edge found, verify that shape is manifold
            if ( edge.Triangle(1) == INVALID_INDEX )
            {
                edge.Triangle(1) = uiT;
            }
            else
            {
                assert( uiT == edge.Triangle(0) || uiT == edge.Triangle(1) );
            }
            return uiE;
        }
    }

    // increase edge array (if necessary)
    if ( m_uiEdgesUsed == m_uiEdgeQuantity )
    {
        unsigned int uiNewQuantity = m_uiEdgeQuantity;
        m_akEdge.Resize(m_uiEdgeQuantity,uiNewQuantity,true);
    }

    // edge not found, add new one
    EdgeRecord& edge = m_akEdge[m_uiEdgesUsed];
    edge.Vertex(0) = uiV0;
    edge.Vertex(1) = uiV1;
    edge.Triangle(0) = uiT;
    edge.Triangle(1) = INVALID_INDEX;
    uiE = m_uiEdgesUsed++;
    return uiE;
}
//---------------------------------------------------------------------------
void MgcGPTriMesh::InsertTriangle (unsigned int uiV0, unsigned int uiV1,
    unsigned int uiV2)
{
    // increase triangle array (if necessary)
    if ( m_uiTrianglesUsed == m_uiTriangleQuantity )
    {
        unsigned int uiNewQuantity = m_uiTriangleQuantity +
            ms_uiTriangleGrowBy;
        m_akTriangle.Resize(m_uiTriangleQuantity,uiNewQuantity,true);
        m_akFacetPlane.Resize(m_uiTriangleQuantity,uiNewQuantity,true);
    }

    // add edges to mesh
    unsigned int uiE0 = AddEdge(uiV0,uiV1,m_uiTrianglesUsed);
    unsigned int uiE1 = AddEdge(uiV1,uiV2,m_uiTrianglesUsed);
    unsigned int uiE2 = AddEdge(uiV2,uiV0,m_uiTrianglesUsed);

    // update triangle
    TriangleRecord& tri = m_akTriangle[m_uiTrianglesUsed];
    tri.Vertex(0) = uiV0;
    tri.Vertex(1) = uiV1;
    tri.Vertex(2) = uiV2;
    tri.Edge(0) = uiE0;
    tri.Edge(1) = uiE1;
    tri.Edge(2) = uiE2;

    // compute facet plane
    MgcPlane& rkPlane = m_akFacetPlane[m_uiTrianglesUsed];
    MgcVector3 kEdge0 = m_akVertex[uiV1] - m_akVertex[uiV0];
    MgcVector3 kEdge1 = m_akVertex[uiV2] - m_akVertex[uiV1];
    MgcVector3 kNormal = kEdge0.Cross(kEdge1);
    rkPlane.Normal() = kNormal;
    rkPlane.Constant() = kNormal.Dot(m_akVertex[uiV0]);

    m_uiTrianglesUsed++;
}
//---------------------------------------------------------------------------
void MgcGPTriMesh::GetTriangle (unsigned int uiT, unsigned int& uiV0,
    unsigned int& uiV1, unsigned int& uiV2) const
{
    assert( uiT < m_uiTrianglesUsed );

    TriangleRecord& tri = m_akTriangle[uiT];
    uiV0 = tri.Vertex(0);
    uiV1 = tri.Vertex(1);
    uiV2 = tri.Vertex(2);
}
//---------------------------------------------------------------------------
void MgcGPTriMesh::RemoveTriangle (unsigned int uiT)
{
    // TO DO.  Implement.
}
//---------------------------------------------------------------------------
void MgcGPTriMesh::UpdateModelBound ()
{
    m_kBound.ComputeFromData(m_uiVerticesUsed,m_akVertex.GetStorage());
}
//---------------------------------------------------------------------------
void MgcGPTriMesh::Draw (MgcRenderer& rkRenderer)
{
    MgcGeometry::Draw(rkRenderer);

    MgcRenderer* pkRenderer = &rkRenderer;
    MgcGPRenderer* pkGPRenderer = MgcDynamicCast(MgcGPRenderer,pkRenderer);
    assert( pkGPRenderer );
    pkGPRenderer->Draw(*this);
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// streaming
//---------------------------------------------------------------------------
MgcObject* MgcGPTriMesh::Factory (MgcStream& rkStream)
{
    MgcGPTriMesh* pkObject = new MgcGPTriMesh;
    MgcStream::Link* pkLink = new MgcStream::Link(pkObject);
    pkObject->Load(rkStream,pkLink);
    return pkObject;
}
//---------------------------------------------------------------------------
void MgcGPTriMesh::Load (MgcStream& rkStream, MgcStream::Link* pkLink)
{
    MgcGeometry::Load(rkStream,pkLink);
}
//---------------------------------------------------------------------------
void MgcGPTriMesh::Link (MgcStream& rkStream, MgcStream::Link* pkLink)
{
    MgcGeometry::Link(rkStream,pkLink);
}
//---------------------------------------------------------------------------
bool MgcGPTriMesh::Register (MgcStream& rkStream)
{
    return MgcGeometry::Register(rkStream);
}
//---------------------------------------------------------------------------
void MgcGPTriMesh::Save (MgcStream& rkStream)
{
    MgcGeometry::Save(rkStream);
}
//---------------------------------------------------------------------------