wmlbsptree.cpp

3D Game Engine Design Source Code非常棒

                kT12 = *apkT[i1] + fT*(*apkT[i2] - *apkT[i1]);

            AddTriangle(rkPositive,kV01,kV12,rkV0,bHasNormals,&kN01,&kN12,
                apkN[i0],bHasColors,&kC01,&kC12,apkC[i0],bHasTextures,&kT01,
                &kT12,apkT[i0]);

            AddTriangle(rkPositive,kV12,rkV2,rkV0,bHasNormals,&kN12,apkN[i2],
                apkN[i0],bHasColors,&kC12,apkC[i2],apkC[i0],bHasTextures,
                &kT12,apkT[i2],apkT[i0]);

            AddTriangle(rkNegative,kV01,rkV1,kV12,bHasNormals,&kV01,apkN[i1],
                &kN12,bHasColors,&kC01,apkC[i1],&kC12,bHasTextures,&kT01,
                apkT[i1],&kT12);
        }
        else if ( fD2 < 0.0f )
        {
            // clip edge <I0,I2>
            fT = fD2/(fD2 - fD0);
            kV12 = rkV2 + fT*(rkV0 - rkV2);

            if ( bHasNormals )
            {
                kN12 = *apkN[i2] + fT*(*apkN[i0] - *apkN[i2]);
                kN12.Normalize();
            }

            if ( bHasColors )
                kC12 = *apkC[i2] + fT*(*apkC[i0] - *apkC[i2]);

            if ( bHasTextures )
                kT12 = *apkT[i2] + fT*(*apkT[i0] - *apkT[i2]);

            AddTriangle(rkPositive,kV01,kV12,rkV0,bHasNormals,&kN01,&kN12,
                apkN[i0],bHasColors,&kC01,&kC12,apkC[i0],bHasTextures,&kT01,
                &kT12,apkT[i0]);

            AddTriangle(rkNegative,kV01,rkV1,rkV2,bHasNormals,&kN01,apkN[i1],
                apkN[i2],bHasColors,&kC01,apkC[i1],apkC[i2],bHasTextures,
                &kT01,apkT[i1],apkT[i2]);

            AddTriangle(rkNegative,kV01,rkV2,kV12,bHasNormals,&kN01,apkN[i2],
                &kN12,bHasColors,&kC01,apkC[i2],&kC12,bHasTextures,&kT01,
                apkT[i2],&kT12);
        }
        else
        {
            AddTriangle(rkPositive,kV01,rkV2,rkV0,bHasNormals,&kN01,apkN[i2],
                apkN[i0],bHasColors,&kC01,apkC[i2],apkC[i0],bHasTextures,
                &kT01,apkT[i2],apkT[i0]);

            AddTriangle(rkNegative,kV01,rkV1,rkV2,bHasNormals,&kN01,apkN[i1],
                apkN[i2],bHasColors,&kC01,apkC[i1],apkC[i2],bHasTextures,
                &kT01,apkT[i1],apkT[i2]);
        }
    }
    else
    {
        if ( fD2 > 0.0f )
        {
            // clip edge <I0,I2>
            fT = fD0/(fD0 - fD2);
            kV12 = rkV0 + fT*(rkV2 - rkV0);

            if ( bHasNormals )
            {
                kN12 = *apkN[i0] + fT*(*apkN[i2] - *apkN[i0]);
                kN12.Normalize();
            }

            if ( bHasColors )
                kC12 = *apkC[i0] + fT*(*apkC[i2] - *apkC[i0]);

            if ( bHasTextures )
                kT12 = *apkT[i0] + fT*(*apkT[i2] - *apkT[i0]);

            AddTriangle(rkPositive,kV01,rkV1,rkV2,bHasNormals,&kN01,apkN[i1],
                apkN[i2],bHasColors,&kC01,apkC[i1],apkC[i2],bHasTextures,
                &kT01,apkT[i1],apkT[i2]);

            AddTriangle(rkPositive,kV01,rkV2,kV12,bHasNormals,&kN01,apkN[i2],
                &kN12,bHasColors,&kC01,apkC[i2],&kC12,bHasTextures,&kT01,
                apkT[i2],&kT12);

            AddTriangle(rkNegative,kV01,kV12,rkV0,bHasNormals,&kN01,&kN12,
                apkN[i0],bHasColors,&kC01,&kC12,apkC[i0],bHasTextures,&kT01,
                &kT12,apkT[i0]);
        }
        else if ( fD2 < 0.0f )
        {
            // clip edge <I1,I2>
            fT = fD2/(fD2 - fD1);
            kV12 = rkV2 + fT*(rkV1 - rkV2);

            if ( bHasNormals )
            {
                kN12 = *apkN[i2] + fT*(*apkN[i1] - *apkN[i2]);
                kN12.Normalize();
            }

            if ( bHasColors )
                kC12 = *apkC[i2] + fT*(*apkC[i1] - *apkC[i2]);

            if ( bHasTextures )
                kT12 = *apkT[i2] + fT*(*apkT[i1] - *apkT[i2]);

            AddTriangle(rkPositive,kV01,rkV1,kV12,bHasNormals,&kN01,apkN[i1],
                &kN12,bHasColors,&kC01,apkC[i1],&kC12,bHasTextures,&kT01,
                apkT[i1],&kT12);

            AddTriangle(rkNegative,rkV0,kV01,kV12,bHasNormals,apkN[i0],&kN01,
                &kN12,bHasColors,apkC[i0],&kC01,&kC12,bHasTextures,apkT[i0],
                &kT01,&kT12);

            AddTriangle(rkNegative,rkV0,kV12,rkV2,bHasNormals,apkN[i0],&kN01,
                apkN[i2],bHasColors,apkC[i0],&kC12,apkC[i2],bHasTextures,
                apkT[i0],&kT12,apkT[i2]);
        }
        else
        {
            AddTriangle(rkPositive,kV01,rkV1,rkV2,bHasNormals,&kN01,apkN[i1],
                apkN[i2],bHasColors,&kC01,apkC[i1],apkC[i2],bHasTextures,
                &kT01,apkT[i1],apkT[i2]);

            AddTriangle(rkNegative,kV01,rkV2,rkV0,bHasNormals,&kN01,apkN[i2],
                apkN[i0],bHasColors,&kC01,apkC[i2],apkC[i0],bHasTextures,
                &kT01,apkT[i2],apkT[i0]);
        }
    }
}
//----------------------------------------------------------------------------
void BspTree::AddTriangle (TriangleList& rkList, const Vector3f& rkV0,
    const Vector3f& rkV1, const Vector3f& rkV2, bool bHasNormals,
    const Vector3f* pkN0, const Vector3f* pkN1, const Vector3f* pkN2,
    bool bHasColors, const ColorRGB* pkC0, const ColorRGB* pkC1,
    const ColorRGB* pkC2, bool bHasTextures, const Vector2f* pkT0,
    const Vector2f* pkT1, const Vector2f* pkT2)
{
    Triangle* pkClipTri = new Triangle;
    rkList.push_front(pkClipTri);

    pkClipTri->m_akVertex[0] = rkV0;
    pkClipTri->m_akVertex[1] = rkV1;
    pkClipTri->m_akVertex[2] = rkV2;

    if ( bHasNormals )
    {
        pkClipTri->m_apkNormal[0] = new Vector3f;
        pkClipTri->m_apkNormal[1] = new Vector3f;
        pkClipTri->m_apkNormal[2] = new Vector3f;
        *pkClipTri->m_apkNormal[0] = *pkN0;
        *pkClipTri->m_apkNormal[1] = *pkN1;
        *pkClipTri->m_apkNormal[2] = *pkN2;
    }

    if ( bHasColors )
    {
        pkClipTri->m_apkColor[0] = new ColorRGB;
        pkClipTri->m_apkColor[1] = new ColorRGB;
        pkClipTri->m_apkColor[2] = new ColorRGB;
        *pkClipTri->m_apkColor[0] = *pkC0;
        *pkClipTri->m_apkColor[1] = *pkC1;
        *pkClipTri->m_apkColor[2] = *pkC2;
    }

    if ( bHasTextures )
    {
        pkClipTri->m_apkTexture[0] = new Vector2f;
        pkClipTri->m_apkTexture[1] = new Vector2f;
        pkClipTri->m_apkTexture[2] = new Vector2f;
        *pkClipTri->m_apkTexture[0] = *pkT0;
        *pkClipTri->m_apkTexture[1] = *pkT1;
        *pkClipTri->m_apkTexture[2] = *pkT2;
    }
}
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// streaming
//----------------------------------------------------------------------------
Object* BspTree::Factory (Stream& rkStream)
{
    BspTree* pkObject = new BspTree;
    Stream::Link* pkLink = new Stream::Link(pkObject);
    pkObject->Load(rkStream,pkLink);
    return pkObject;
}
//----------------------------------------------------------------------------
void BspTree::Load (Stream& rkStream, Stream::Link* pkLink)
{
    BspNode::Load(rkStream,pkLink);
}
//----------------------------------------------------------------------------
void BspTree::Link (Stream& rkStream, Stream::Link* pkLink)
{
    BspNode::Link(rkStream,pkLink);
}
//----------------------------------------------------------------------------
bool BspTree::Register (Stream& rkStream)
{
    return BspNode::Register(rkStream);
}
//----------------------------------------------------------------------------
void BspTree::Save (Stream& rkStream)
{
    BspNode::Save(rkStream);
}
//----------------------------------------------------------------------------
StringTree* BspTree::SaveStrings ()
{
    // TO DO.  Finish implementation.
    StringTree* pkTree = new StringTree(1,0,1,0);
    pkTree->SetString(0,MakeString(&ms_kRTTI,GetName()));
    pkTree->SetChild(0,BspNode::SaveStrings());
    return pkTree;
}
//----------------------------------------------------------------------------
int BspTree::GetMemoryUsed () const
{
    int iBaseSize = sizeof(BspTree) - sizeof(BspNode);
    int iTotalSize = iBaseSize + BspNode::GetMemoryUsed();
    return iTotalSize;
}
//----------------------------------------------------------------------------
int BspTree::GetDiskUsed () const
{
    return BspNode::GetDiskUsed();
}
//----------------------------------------------------------------------------