wmlbezierrectangle2.cpp

3D Game Engine Design Source Code非常棒

    // colors
    ColorRGB kCss0M, kCttM0;
    if ( akColor )
    {
        // top and bottom s-edge subdivision
        kCttM0 = 0.5f*(rkBP.m_akCtt[0]+rkBP.m_akCtt[1]-fDSqr*rkCsstt);
        akColor[iM0] = 0.5f*(akColor[rkBP.m_i00] + akColor[rkBP.m_i10] -
            fDSqr*rkBP.m_akCss[0]);
        akColor[iM1] = 0.5f*(akColor[rkBP.m_i01] + akColor[rkBP.m_i11] -
            fDSqr*rkBP.m_akCss[1]);

        // left and right t-edge subdivision
        kCss0M = 0.5f*(rkBP.m_akCss[0]+rkBP.m_akCss[1]-fDSqr*rkCsstt);
        akColor[i0M] = 0.5f*(akColor[rkBP.m_i00] + akColor[rkBP.m_i01] -
            fDSqr*rkBP.m_akCtt[0]);
        akColor[i1M] = 0.5f*(akColor[rkBP.m_i10] + akColor[rkBP.m_i11] -
            fDSqr*rkBP.m_akCtt[1]);

        // center subdivision
        akColor[iMM] = 0.5f*(akColor[i0M] + akColor[i1M] - fDSqr*kCss0M);
    }

    // textures
    Vector2f kTss0M, kTttM0;
    if ( akTexture )
    {
        // top and bottom s-edge subdivision
        kTttM0 = 0.5f*(rkBP.m_akTtt[0]+rkBP.m_akTtt[1]-fDSqr*rkTsstt);
        akTexture[iM0] = 0.5f*(akTexture[rkBP.m_i00] +
            akTexture[rkBP.m_i10] - fDSqr*rkBP.m_akTss[0]);
        akTexture[iM1] = 0.5f*(akTexture[rkBP.m_i01] +
            akTexture[rkBP.m_i11] - fDSqr*rkBP.m_akTss[1]);

        // left and right t-edge subdivision
        kTss0M = 0.5f*(rkBP.m_akTss[0]+rkBP.m_akTss[1]-fDSqr*rkTsstt);
        akTexture[i0M] = 0.5f*(akTexture[rkBP.m_i00] +
            akTexture[rkBP.m_i01] - fDSqr*rkBP.m_akTtt[0]);
        akTexture[i1M] = 0.5f*(akTexture[rkBP.m_i10] +
            akTexture[rkBP.m_i11] - fDSqr*rkBP.m_akTtt[1]);

        // center subdivision
        akTexture[iMM] = 0.5f*(akTexture[i0M] + akTexture[i1M] -
            fDSqr*kTss0M);
    }

    // recurse on four children
    if ( iLevel > 0 )
    {
        iLevel--;
        fDSqr *= 0.25f;

        BlockParameters kSubBP;

        // subblock [s0,sM]x[t0,tM]
        kSubBP.m_i00 = rkBP.m_i00;
        kSubBP.m_i01 = i0M;
        kSubBP.m_i10 = iM0;
        kSubBP.m_i11 = iMM;

        kSubBP.m_akXss[0] = rkBP.m_akXss[0];
        kSubBP.m_akXss[1] = kXss0M;
        kSubBP.m_akXtt[0] = rkBP.m_akXtt[0];
        kSubBP.m_akXtt[1] = kXttM0;

        if ( akXs )
        {
            kSubBP.m_akXsst[0] = rkBP.m_akXsst[0];
            kSubBP.m_akXsst[1] = kXsst0M;
            kSubBP.m_akXstt[0] = rkBP.m_akXstt[0];
            kSubBP.m_akXstt[1] = kXsttM0;
        }

        if ( akColor )
        {
            kSubBP.m_akCss[0] = rkBP.m_akCss[0];
            kSubBP.m_akCss[1] = kCss0M;
            kSubBP.m_akCtt[0] = rkBP.m_akCtt[0];
            kSubBP.m_akCtt[1] = kCttM0;
        }

        if ( akTexture )
        {
            kSubBP.m_akTss[0] = rkBP.m_akTss[0];
            kSubBP.m_akTss[1] = kTss0M;
            kSubBP.m_akTtt[0] = rkBP.m_akTtt[0];
            kSubBP.m_akTtt[1] = kTttM0;
        }

        Subdivide(iLevel,fDSqr,akX,akXs,akXt,akColor,akTexture,rkXsstt,
            rkCsstt,rkTsstt,kSubBP);

        // subblock [s0,sM]x[tM,t1]
        kSubBP.m_i00 = i0M;
        kSubBP.m_i01 = rkBP.m_i01;
        kSubBP.m_i10 = iMM;
        kSubBP.m_i11 = iM1;

        kSubBP.m_akXss[0] = kXss0M;
        kSubBP.m_akXss[1] = rkBP.m_akXss[1];
        kSubBP.m_akXtt[0] = rkBP.m_akXtt[0];
        kSubBP.m_akXtt[1] = kXttM0;

        if ( akXs )
        {
            kSubBP.m_akXsst[0] = kXsst0M;
            kSubBP.m_akXsst[1] = rkBP.m_akXsst[1];
            kSubBP.m_akXstt[0] = rkBP.m_akXstt[0];
            kSubBP.m_akXstt[1] = kXsttM0;
        }

        if ( akColor )
        {
            kSubBP.m_akCss[0] = kCss0M;
            kSubBP.m_akCss[1] = rkBP.m_akCss[1];
            kSubBP.m_akCtt[0] = rkBP.m_akCtt[0];
            kSubBP.m_akCtt[1] = kCttM0;
        }

        if ( akTexture )
        {
            kSubBP.m_akTss[0] = kTss0M;
            kSubBP.m_akTss[1] = rkBP.m_akTss[1];
            kSubBP.m_akTtt[0] = rkBP.m_akTtt[0];
            kSubBP.m_akTtt[1] = kTttM0;
        }

        Subdivide(iLevel,fDSqr,akX,akXs,akXt,akColor,akTexture,rkXsstt,
            rkCsstt,rkTsstt,kSubBP);

        // subblock [sM,s1]x[t0,tM]
        kSubBP.m_i00 = iM0;
        kSubBP.m_i01 = iMM;
        kSubBP.m_i10 = rkBP.m_i10;
        kSubBP.m_i11 = i1M;

        kSubBP.m_akXss[0] = rkBP.m_akXss[0];
        kSubBP.m_akXss[1] = kXss0M;
        kSubBP.m_akXtt[0] = kXttM0;
        kSubBP.m_akXtt[1] = rkBP.m_akXtt[1];

        if ( akXs )
        {
            kSubBP.m_akXsst[0] = rkBP.m_akXsst[0];
            kSubBP.m_akXsst[1] = kXsst0M;
            kSubBP.m_akXstt[0] = kXsttM0;
            kSubBP.m_akXstt[1] = rkBP.m_akXstt[1];
        }

        if ( akColor )
        {
            kSubBP.m_akCss[0] = rkBP.m_akCss[0];
            kSubBP.m_akCss[1] = kCss0M;
            kSubBP.m_akCtt[0] = kCttM0;
            kSubBP.m_akCtt[1] = rkBP.m_akCtt[1];
        }

        if ( akTexture )
        {
            kSubBP.m_akTss[0] = rkBP.m_akTss[0];
            kSubBP.m_akTss[1] = kTss0M;
            kSubBP.m_akTtt[0] = kTttM0;
            kSubBP.m_akTtt[1] = rkBP.m_akTtt[1];
        }

        Subdivide(iLevel,fDSqr,akX,akXs,akXt,akColor,akTexture,rkXsstt,
            rkCsstt,rkTsstt,kSubBP);

        // subblock [sM,s1]x[tM,t1]
        kSubBP.m_i00 = iMM;
        kSubBP.m_i01 = iM1;
        kSubBP.m_i10 = i1M;
        kSubBP.m_i11 = rkBP.m_i11;

        kSubBP.m_akXss[0] = kXss0M;
        kSubBP.m_akXss[1] = rkBP.m_akXss[1];
        kSubBP.m_akXtt[0] = kXttM0;
        kSubBP.m_akXtt[1] = rkBP.m_akXtt[1];

        if ( akXs )
        {
            kSubBP.m_akXsst[0] = kXsst0M;
            kSubBP.m_akXsst[1] = rkBP.m_akXsst[1];
            kSubBP.m_akXstt[0] = kXsttM0;
            kSubBP.m_akXstt[1] = rkBP.m_akXstt[1];
        }

        if ( akColor )
        {
            kSubBP.m_akCss[0] = kCss0M;
            kSubBP.m_akCss[1] = rkBP.m_akCss[1];
            kSubBP.m_akCtt[0] = kCttM0;
            kSubBP.m_akCtt[1] = rkBP.m_akCtt[1];
        }

        if ( akTexture )
        {
            kSubBP.m_akTss[0] = kTss0M;
            kSubBP.m_akTss[1] = rkBP.m_akTss[1];
            kSubBP.m_akTtt[0] = kTttM0;
            kSubBP.m_akTtt[1] = rkBP.m_akTtt[1];
        }

        Subdivide(iLevel,fDSqr,akX,akXs,akXt,akColor,akTexture,rkXsstt,
            rkCsstt,rkTsstt,kSubBP);
    }
}
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// streaming
//----------------------------------------------------------------------------
Object* BezierRectangle2::Factory (Stream& rkStream)
{
    BezierRectangle2* pkObject = new BezierRectangle2;
    Stream::Link* pkLink = new Stream::Link(pkObject);
    pkObject->Load(rkStream,pkLink);
    return pkObject;
}
//----------------------------------------------------------------------------
void BezierRectangle2::Load (Stream& rkStream, Stream::Link* pkLink)
{
    BezierRectangle::Load(rkStream,pkLink);
}
//----------------------------------------------------------------------------
void BezierRectangle2::Link (Stream& rkStream, Stream::Link* pkLink)
{
    BezierRectangle::Link(rkStream,pkLink);
}
//----------------------------------------------------------------------------
bool BezierRectangle2::Register (Stream& rkStream)
{
    return BezierRectangle::Register(rkStream);
}
//----------------------------------------------------------------------------
void BezierRectangle2::Save (Stream& rkStream)
{
    BezierRectangle::Save(rkStream);
}
//----------------------------------------------------------------------------
StringTree* BezierRectangle2::SaveStrings ()
{
    StringTree* pkTree = new StringTree(1,0,1,0);

    // strings
    pkTree->SetString(0,MakeString(&ms_kRTTI,GetName()));

    // children
    pkTree->SetChild(0,BezierRectangle::SaveStrings());

    return pkTree;
}
//----------------------------------------------------------------------------
int BezierRectangle2::GetMemoryUsed () const
{
    int iBaseSize = sizeof(BezierRectangle2) - sizeof(BezierRectangle);
    int iTotalSize = iBaseSize + BezierRectangle::GetMemoryUsed();
    return iTotalSize;
}
//----------------------------------------------------------------------------
int BezierRectangle2::GetDiskUsed () const
{
    return BezierRectangle::GetDiskUsed();
}
//----------------------------------------------------------------------------