wmlbezierrectangle3.cpp

3D Game Engine Design Source Code非常棒

    BlockParameters& rkBP)
{
    // subdivision indices
    int iM0 = (rkBP.m_i00 + rkBP.m_i10) >> 1;
    int iM1 = (rkBP.m_i01 + rkBP.m_i11) >> 1;
    int i0M = (rkBP.m_i00 + rkBP.m_i01) >> 1;
    int i1M = (rkBP.m_i10 + rkBP.m_i11) >> 1;
    int iMM = (i0M + i1M) >> 1;

    // vertices

    // top and bottom s-edge subdivision
    Vector3f kXssM0 = 0.5f*(rkBP.m_aakXss[0][0] + rkBP.m_aakXss[1][0]);
    Vector3f kXssM1 = 0.5f*(rkBP.m_aakXss[0][1] + rkBP.m_aakXss[1][1]);
    Vector3f kXssttM0 = 0.5f*(rkBP.m_aakXsstt[0][0] + rkBP.m_aakXsstt[1][0]);
    Vector3f kXssttM1 = 0.5f*(rkBP.m_aakXsstt[0][1] + rkBP.m_aakXsstt[1][1]);
    Vector3f kXttM0 = 0.5f*(rkBP.m_aakXtt[0][0] + rkBP.m_aakXtt[1][0] -
        fDSqr*kXssttM0);
    Vector3f kXttM1 = 0.5f*(rkBP.m_aakXtt[0][1] + rkBP.m_aakXtt[1][1] -
        fDSqr*kXssttM1);
    akX[iM0] = 0.5f*(akX[rkBP.m_i00] + akX[rkBP.m_i10] - fDSqr*kXssM0);
    akX[iM1] = 0.5f*(akX[rkBP.m_i01] + akX[rkBP.m_i11] - fDSqr*kXssM1);

    // left and right t-edge subdivision
    Vector3f kXtt0M = 0.5f*(rkBP.m_aakXtt[0][0] + rkBP.m_aakXtt[0][1]);
    Vector3f kXtt1M = 0.5f*(rkBP.m_aakXtt[1][0] + rkBP.m_aakXtt[1][1]);
    Vector3f kXsstt0M = 0.5f*(rkBP.m_aakXsstt[0][0] + rkBP.m_aakXsstt[0][1]);
    Vector3f kXsstt1M = 0.5f*(rkBP.m_aakXsstt[1][0] + rkBP.m_aakXsstt[1][1]);
    Vector3f kXss0M = 0.5f*(rkBP.m_aakXss[0][0] + rkBP.m_aakXss[0][1] -
        fDSqr*kXsstt0M);
    Vector3f kXss1M = 0.5f*(rkBP.m_aakXss[1][0] + rkBP.m_aakXss[1][1] -
        fDSqr*kXsstt1M);
    akX[i0M] = 0.5f*(akX[rkBP.m_i00] + akX[rkBP.m_i01] - fDSqr*kXtt0M);
    akX[i1M] = 0.5f*(akX[rkBP.m_i10] + akX[rkBP.m_i11] - fDSqr*kXtt1M);

    // center subdivision
    Vector3f kXssMM = 0.5f*(kXss0M + kXss1M);
    Vector3f kXttMM = 0.5f*(kXttM0 + kXttM1);
    Vector3f kXssttMM = 0.5f*(kXsstt0M + kXsstt1M);
    akX[iMM] = 0.5f*(akX[i0M] + akX[i1M] - fDSqr*kXssMM);

    // derivatives (for normal vectors)
    Vector3f kXsss0M, kXsttM0, kXsttM1, kXstt0M, kXstt1M, kXssstt0M, kXsttMM;
    Vector3f kXsstM0, kXsstM1, kXsst0M, kXsst1M, kXtttM0, kXsstttM0, kXsstMM;
    if ( akXs )
    {
        // top and bottom s-edge subdivision
        kXsstM0 = 0.5f*(rkBP.m_aakXsst[0][0] + rkBP.m_aakXsst[1][0]);
        kXsstM1 = 0.5f*(rkBP.m_aakXsst[0][1] + rkBP.m_aakXsst[1][1]);
        akXs[iM0] = 0.5f*(akXs[rkBP.m_i00] + akXs[rkBP.m_i10] -
            fDSqr*rkBP.m_akXsss[0]);
        akXt[iM0] = 0.5f*(akXt[rkBP.m_i00] + akXt[rkBP.m_i10] -
            fDSqr*kXsstM0);
        akXs[iM1] = 0.5f*(akXs[rkBP.m_i01] + akXs[rkBP.m_i11] -
            fDSqr*rkBP.m_akXsss[1]);
        akXt[iM1] = 0.5f*(akXt[rkBP.m_i01] + akXt[rkBP.m_i11] -
            fDSqr*kXsstM1);

        kXsttM0 = 0.5f*(rkBP.m_aakXstt[0][0] + rkBP.m_aakXstt[1][0] -
            fDSqr*rkBP.m_akXssstt[0]);
        kXsstttM0 = 0.5f*(rkBP.m_akXssttt[0] + rkBP.m_akXssttt[1]);
        kXtttM0 = 0.5f*(rkBP.m_akXttt[0] + rkBP.m_akXttt[1] -
            fDSqr*kXsstttM0);
        kXsttM1 = 0.5f*(rkBP.m_aakXstt[0][1] + rkBP.m_aakXstt[1][1] -
            fDSqr*rkBP.m_akXssstt[1]);

        // left and right t-edge subdivision
        kXstt0M = 0.5f*(rkBP.m_aakXstt[0][0] + rkBP.m_aakXstt[0][1]);
        kXstt1M = 0.5f*(rkBP.m_aakXstt[1][0] + rkBP.m_aakXstt[1][1]);
        akXs[i0M] = 0.5f*(akXs[rkBP.m_i00] + akXs[rkBP.m_i01] -
            fDSqr*kXstt0M);
        akXt[i0M] = 0.5f*(akXt[rkBP.m_i00] + akXt[rkBP.m_i01] -
            fDSqr*rkBP.m_akXttt[0]);
        akXs[i1M] = 0.5f*(akXs[rkBP.m_i10] + akXs[rkBP.m_i11] -
            fDSqr*kXstt1M);
        akXt[i1M] = 0.5f*(akXt[rkBP.m_i10] + akXt[rkBP.m_i11] -
            fDSqr*rkBP.m_akXttt[1]);

        kXsst0M = 0.5f*(rkBP.m_aakXsst[0][0] + rkBP.m_aakXsst[0][1] -
            fDSqr*rkBP.m_akXssttt[0]);
        kXssstt0M = 0.5f*(rkBP.m_akXssstt[0] + rkBP.m_akXssstt[1]);
        kXsss0M = 0.5f*(rkBP.m_akXsss[0] + rkBP.m_akXsss[1] -
            fDSqr*kXssstt0M);
        kXsst1M = 0.5f*(rkBP.m_aakXsst[1][0] + rkBP.m_aakXsst[1][1] -
            fDSqr*rkBP.m_akXssttt[1]);

        // center subdivision
        kXsstMM = 0.5f*(kXsst0M + kXsst1M);
        kXsttMM = 0.5f*(kXsttM0 + kXsttM1);
        akXs[iMM] = 0.5f*(akXs[i0M] + akXs[i1M] - fDSqr*kXsss0M);
        akXt[iMM] = 0.5f*(akXt[iM0] + akXt[iM1] - fDSqr*kXtttM0);
    }

    // colors
    ColorRGB kCssM0, kCssM1, kCss0M, kCss1M, kCttM0, kCttM1, kCtt0M, kCtt1M,
        kCssttM0, kCssttM1, kCsstt0M, kCsstt1M, kCssMM, kCttMM, kCssttMM;
    if ( akColor )
    {
        // top and bottom s-edge subdivision
        kCssM0 = 0.5f*(rkBP.m_aakCss[0][0] + rkBP.m_aakCss[1][0]);
        kCssM1 = 0.5f*(rkBP.m_aakCss[0][1] + rkBP.m_aakCss[1][1]);
        kCssttM0 = 0.5f*(rkBP.m_aakCsstt[0][0] + rkBP.m_aakCsstt[1][0]);
        kCssttM1 = 0.5f*(rkBP.m_aakCsstt[0][1] + rkBP.m_aakCsstt[1][1]);
        kCttM0 = 0.5f*(rkBP.m_aakCtt[0][0] + rkBP.m_aakCtt[1][0] -
            fDSqr*kCssttM0);
        kCttM1 = 0.5f*(rkBP.m_aakCtt[0][1] + rkBP.m_aakCtt[1][1] -
            fDSqr*kCssttM1);
        akColor[iM0] = 0.5f*(akColor[rkBP.m_i00] + akColor[rkBP.m_i10] -
            fDSqr*kCssM0);
        akColor[iM1] = 0.5f*(akColor[rkBP.m_i01] + akColor[rkBP.m_i11] -
            fDSqr*kCssM1);

        // left and right t-edge subdivision
        kCtt0M = 0.5f*(rkBP.m_aakCtt[0][0] + rkBP.m_aakCtt[0][1]);
        kCtt1M = 0.5f*(rkBP.m_aakCtt[1][0] + rkBP.m_aakCtt[1][1]);
        kCsstt0M = 0.5f*(rkBP.m_aakCsstt[0][0] + rkBP.m_aakCsstt[0][1]);
        kCsstt1M = 0.5f*(rkBP.m_aakCsstt[1][0] + rkBP.m_aakCsstt[1][1]);
        kCss0M = 0.5f*(rkBP.m_aakCss[0][0] + rkBP.m_aakCss[0][1] -
            fDSqr*kCsstt0M);
        kCss1M = 0.5f*(rkBP.m_aakCss[1][0] + rkBP.m_aakCss[1][1] -
            fDSqr*kCsstt1M);
        akColor[i0M] = 0.5f*(akColor[rkBP.m_i00] + akColor[rkBP.m_i01] -
            fDSqr*kCtt0M);
        akColor[i1M] = 0.5f*(akColor[rkBP.m_i10] + akColor[rkBP.m_i11] -
            fDSqr*kCtt1M);

        // center subdivision
        kCssMM = 0.5f*(kCss0M + kCss1M);
        kCttMM = 0.5f*(kCttM0 + kCttM1);
        kCssttMM = 0.5f*(kCsstt0M + kCsstt1M);
        akColor[iMM] = 0.5f*(akColor[i0M] + akColor[i1M] - fDSqr*kCssMM);
    }

    // textures
    Vector2f kTssM0, kTssM1, kTss0M, kTss1M, kTttM0, kTttM1, kTtt0M, kTtt1M,
        kTssttM0, kTssttM1, kTsstt0M, kTsstt1M, kTssMM, kTttMM, kTssttMM;
    if ( akTexture )
    {
        // top and bottom s-edge subdivision
        kTssM0 = 0.5f*(rkBP.m_aakTss[0][0] + rkBP.m_aakTss[1][0]);
        kTssM1 = 0.5f*(rkBP.m_aakTss[0][1] + rkBP.m_aakTss[1][1]);
        kTssttM0 = 0.5f*(rkBP.m_aakTsstt[0][0] + rkBP.m_aakTsstt[1][0]);
        kTssttM1 = 0.5f*(rkBP.m_aakTsstt[0][1] + rkBP.m_aakTsstt[1][1]);
        kTttM0 = 0.5f*(rkBP.m_aakTtt[0][0] + rkBP.m_aakTtt[1][0] -
            fDSqr*kTssttM0);
        kTttM1 = 0.5f*(rkBP.m_aakTtt[0][1] + rkBP.m_aakTtt[1][1] -
            fDSqr*kTssttM1);
        akTexture[iM0] = 0.5f*(akTexture[rkBP.m_i00] +
            akTexture[rkBP.m_i10] - fDSqr*kTssM0);
        akTexture[iM1] = 0.5f*(akTexture[rkBP.m_i01] +
            akTexture[rkBP.m_i11] - fDSqr*kTssM1);

        // left and right t-edge subdivision
        kTtt0M = 0.5f*(rkBP.m_aakTtt[0][0] + rkBP.m_aakTtt[0][1]);
        kTtt1M = 0.5f*(rkBP.m_aakTtt[1][0] + rkBP.m_aakTtt[1][1]);
        kTsstt0M = 0.5f*(rkBP.m_aakTsstt[0][0] + rkBP.m_aakTsstt[0][1]);
        kTsstt1M = 0.5f*(rkBP.m_aakTsstt[1][0] + rkBP.m_aakTsstt[1][1]);
        kTss0M = 0.5f*(rkBP.m_aakTss[0][0] + rkBP.m_aakTss[0][1] -
            fDSqr*kTsstt0M);
        kTss1M = 0.5f*(rkBP.m_aakTss[1][0] + rkBP.m_aakTss[1][1] -
            fDSqr*kTsstt1M);
        akTexture[i0M] = 0.5f*(akTexture[rkBP.m_i00] +
            akTexture[rkBP.m_i01] - fDSqr*kTtt0M);
        akTexture[i1M] = 0.5f*(akTexture[rkBP.m_i10] +
            akTexture[rkBP.m_i11] - fDSqr*kTtt1M);

        // center subdivision
        kTssMM = 0.5f*(kTss0M + kTss1M);
        kTttMM = 0.5f*(kTttM0 + kTttM1);
        kTssttMM = 0.5f*(kTsstt0M + kTsstt1M);
        akTexture[iMM] = 0.5f*(akTexture[i0M] + akTexture[i1M] -
            fDSqr*kTssMM);
    }

    // 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_aakXss[0][0] = rkBP.m_aakXss[0][0];
        kSubBP.m_aakXss[0][1] = kXss0M;
        kSubBP.m_aakXss[1][0] = kXssM0;
        kSubBP.m_aakXss[1][1] = kXssMM;
        kSubBP.m_aakXtt[0][0] = rkBP.m_aakXtt[0][0];
        kSubBP.m_aakXtt[0][1] = kXtt0M;
        kSubBP.m_aakXtt[1][0] = kXttM0;
        kSubBP.m_aakXtt[1][1] = kXttMM;
        kSubBP.m_aakXsstt[0][0] = rkBP.m_aakXsstt[0][0];
        kSubBP.m_aakXsstt[0][1] = kXsstt0M;
        kSubBP.m_aakXsstt[1][0] = kXssttM0;
        kSubBP.m_aakXsstt[1][1] = kXssttMM;

        if ( akXs )
        {
            kSubBP.m_akXsss[0] = rkBP.m_akXsss[0];
            kSubBP.m_akXsss[1] = kXsss0M;
            kSubBP.m_aakXsst[0][0] = rkBP.m_aakXsst[0][0];
            kSubBP.m_aakXsst[0][1] = kXsst0M;
            kSubBP.m_aakXsst[1][0] = kXsstM0;
            kSubBP.m_aakXsst[1][1] = kXsstMM;
            kSubBP.m_aakXstt[0][0] = rkBP.m_aakXstt[0][0];
            kSubBP.m_aakXstt[0][1] = kXstt0M;
            kSubBP.m_aakXstt[1][0] = kXsttM0;
            kSubBP.m_aakXstt[1][1] = kXsttMM;
            kSubBP.m_akXttt[0] = rkBP.m_akXttt[0];
            kSubBP.m_akXttt[1] = kXtttM0;
            kSubBP.m_akXssstt[0] = rkBP.m_akXssstt[0];
            kSubBP.m_akXssstt[1] = kXssstt0M;
            kSubBP.m_akXssttt[0] = rkBP.m_akXssttt[0];
            kSubBP.m_akXssttt[1] = kXsstttM0;
        }

        if ( akColor )
        {
            kSubBP.m_aakCss[0][0] = rkBP.m_aakCss[0][0];
            kSubBP.m_aakCss[0][1] = kCss0M;
            kSubBP.m_aakCss[1][0] = kCssM0;
            kSubBP.m_aakCss[1][1] = kCssMM;
            kSubBP.m_aakCtt[0][0] = rkBP.m_aakCtt[0][0];
            kSubBP.m_aakCtt[0][1] = kCtt0M;
            kSubBP.m_aakCtt[1][0] = kCttM0;
            kSubBP.m_aakCtt[1][1] = kCttMM;
            kSubBP.m_aakCsstt[0][0] = rkBP.m_aakCsstt[0][0];
            kSubBP.m_aakCsstt[0][1] = kCsstt0M;
            kSubBP.m_aakCsstt[1][0] = kCssttM0;
            kSubBP.m_aakCsstt[1][1] = kCssttMM;
        }

        if ( akTexture )
        {
            kSubBP.m_aakTss[0][0] = rkBP.m_aakTss[0][0];
            kSubBP.m_aakTss[0][1] = kTss0M;
            kSubBP.m_aakTss[1][0] = kTssM0;
            kSubBP.m_aakTss[1][1] = kTssMM;
            kSubBP.m_aakTtt[0][0] = rkBP.m_aakTtt[0][0];
            kSubBP.m_aakTtt[0][1] = kTtt0M;
            kSubBP.m_aakTtt[1][0] = kTttM0;
            kSubBP.m_aakTtt[1][1] = kTttMM;
            kSubBP.m_aakTsstt[0][0] = rkBP.m_aakTsstt[0][0];
            kSubBP.m_aakTsstt[0][1] = kTsstt0M;
            kSubBP.m_aakTsstt[1][0] = kTssttM0;
            kSubBP.m_aakTsstt[1][1] = kTssttMM;
        }

        Subdivide(iLevel,fDSqr,akX,akXs,akXt,akColor,akTexture,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_aakXss[0][0] = kXss0M;
        kSubBP.m_aakXss[0][1] = rkBP.m_aakXss[0][1];
        kSubBP.m_aakXss[1][0] = kXssMM;
        kSubBP.m_aakXss[1][1] = kXssM1;
        kSubBP.m_aakXtt[0][0] = kXtt0M;
        kSubBP.m_aakXtt[0][1] = rkBP.m_aakXtt[0][1];
        kSubBP.m_aakXtt[1][0] = kXttMM;