D:/Zythum/DinoKod/Bsp/BezierPatch.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : BezierPatch.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 07/09/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include "Common/Assert.h"
#include "Common/Vertex.h"
#include "Common/Matrix.h"

#include "Bsp/BezierPatch.h"

//---------------------------------------------------------------------------------------------------------------------
KBezierPatch::KBezierPatch()
{
        m_pVertices     = NULL;
        m_nVertices = 0;
        m_pIndices      = NULL;
        m_nIndices      = 0;
}

//---------------------------------------------------------------------------------------------------------------------
KBezierPatch::~KBezierPatch()
{
        if( m_pVertices )
                Deletev( m_pVertices );
        if( m_pIndices  )
                Deletev( m_pIndices );
}

//---------------------------------------------------------------------------------------------------------------------
void KBezierPatch::GenerateVertices( KLVertex2* pVertices, KPt& PatchSize )
{
        KASSERT( pVertices );
        KASSERT( ( PatchSize.x >= 3 ) && ( PatchSize.y >= 3 ) );

        // Clean si necessaire
        if( m_pVertices )
        {
                Deletev( m_pVertices );
                m_nVertices = 0;
        }

        if( m_pIndices )
        {
                Deletev( m_pIndices );
                m_nIndices = 0;
        }

        u32                             n = 5;  // Nombre de points pour la courbe de bezier
        u32                             nVertex = 0;
        u32                             nIndices = 0;
        s32                             PatchX = 0;
        s32                             PatchY = 0;

        m_nVertices     = (u16)(n * n * (( PatchSize.x - 1 ) / 2) * (( PatchSize.y - 1 ) / 2));
        m_pVertices = new KLVertex2[m_nVertices];
        m_nIndices      = (u16)((n - 1) * (n - 1) * 2 * 3 * (( PatchSize.x - 1 ) / 2) * (( PatchSize.y - 1 ) / 2));
        m_pIndices      = new u16[m_nIndices];

        for( PatchY = 0; PatchY < PatchSize.y - 1; PatchY += 2 )
        for( PatchX = 0; PatchX < PatchSize.x - 1; PatchX += 2 )
        {
                KLVertex2               pControlPoint[16];
                KLVertex2               pVertexPoint[9];
                u32                             x, y;

                // Copie les 9 points de controles BSP
                for( y = 0; y < 3; y ++ )
                for( x = 0; x < 3; x ++ )
                        pVertexPoint[y * 3 + x] = pVertices[(y + PatchY) * PatchSize.x + (x + PatchX)];

                // Genere les 16 points de controles Bézier
                pControlPoint[0] = pVertexPoint[0];
                pControlPoint[1] = (pVertexPoint[0] + pVertexPoint[1]) / 2.0f;
                pControlPoint[2] = (pVertexPoint[1] + pVertexPoint[2]) / 2.0f;
                pControlPoint[3] = pVertexPoint[2];

                pControlPoint[4] = (pVertexPoint[0] + pVertexPoint[3]) / 2.0f;
                pControlPoint[5] = (pVertexPoint[0] + pVertexPoint[1] + pVertexPoint[3] + pVertexPoint[4]) / 4.0f;
                pControlPoint[6] = (pVertexPoint[1] + pVertexPoint[2] + pVertexPoint[4] + pVertexPoint[5]) / 4.0f;
                pControlPoint[7] = (pVertexPoint[2] + pVertexPoint[5]) / 2.0f;

                pControlPoint[8] = (pVertexPoint[3] + pVertexPoint[6]) / 2.0f;
                pControlPoint[9] = (pVertexPoint[3] + pVertexPoint[4] + pVertexPoint[6] + pVertexPoint[7]) / 4.0f;
                pControlPoint[10]= (pVertexPoint[4] + pVertexPoint[5] + pVertexPoint[7] + pVertexPoint[8]) / 4.0f;
                pControlPoint[11]= (pVertexPoint[5] + pVertexPoint[8]) / 2.0f;

                pControlPoint[12]= pVertexPoint[6];
                pControlPoint[13]= (pVertexPoint[6] + pVertexPoint[7]) / 2.0f;
                pControlPoint[14]= (pVertexPoint[7] + pVertexPoint[8]) / 2.0f;
                pControlPoint[15]= pVertexPoint[8];

                double  s, t;

                KLVertex2*      pV = new KLVertex2[n * n];

                for( y = 0; y < n; y ++ )
                for( x = 0; x < n; x ++ )
                {
                        s = (double)(x / (double)(n - 1));
                        t = (double)(y / (double)(n - 1));
                        KASSERT( ( s <= 1.0f ) && ( s >= 0.0f ) );
                        KASSERT( ( t <= 1.0f ) && ( t >= 0.0f ) );

                        KMatrix         mx(     pControlPoint[12].Position.x,   pControlPoint[13].Position.x,   pControlPoint[14].Position.x,   pControlPoint[15].Position.x,
                                                        pControlPoint[8].Position.x,    pControlPoint[9].Position.x,    pControlPoint[10].Position.x,   pControlPoint[11].Position.x,
                                                        pControlPoint[4].Position.x,    pControlPoint[5].Position.x,    pControlPoint[6].Position.x,    pControlPoint[7].Position.x,
                                                        pControlPoint[0].Position.x,    pControlPoint[1].Position.x,    pControlPoint[2].Position.x,    pControlPoint[3].Position.x );

                        KMatrix         my(     pControlPoint[12].Position.y,   pControlPoint[13].Position.y,   pControlPoint[14].Position.y,   pControlPoint[15].Position.y,
                                                        pControlPoint[8].Position.y,    pControlPoint[9].Position.y,    pControlPoint[10].Position.y,   pControlPoint[11].Position.y,
                                                        pControlPoint[4].Position.y,    pControlPoint[5].Position.y,    pControlPoint[6].Position.y,    pControlPoint[7].Position.y,
                                                        pControlPoint[0].Position.y,    pControlPoint[1].Position.y,    pControlPoint[2].Position.y,    pControlPoint[3].Position.y );

                        KMatrix         mz(     pControlPoint[12].Position.z,   pControlPoint[13].Position.z,   pControlPoint[14].Position.z,   pControlPoint[15].Position.z,
                                                        pControlPoint[8].Position.z,    pControlPoint[9].Position.z,    pControlPoint[10].Position.z,   pControlPoint[11].Position.z,
                                                        pControlPoint[4].Position.z,    pControlPoint[5].Position.z,    pControlPoint[6].Position.z,    pControlPoint[7].Position.z,
                                                        pControlPoint[0].Position.z,    pControlPoint[1].Position.z,    pControlPoint[2].Position.z,    pControlPoint[3].Position.z );
                        
                        KMatrix mcolora(        (float)KGETA(pControlPoint[12].Color),          (float)KGETA(pControlPoint[13].Color),  (float)KGETA(pControlPoint[14].Color),  (float)KGETA(pControlPoint[15].Color),
                                                                (float)KGETA(pControlPoint[8].Color),           (float)KGETA(pControlPoint[9].Color),   (float)KGETA(pControlPoint[10].Color),  (float)KGETA(pControlPoint[11].Color),
                                                                (float)KGETA(pControlPoint[4].Color),           (float)KGETA(pControlPoint[5].Color),   (float)KGETA(pControlPoint[6].Color),   (float)KGETA(pControlPoint[7].Color),
                                                                (float)KGETA(pControlPoint[0].Color),           (float)KGETA(pControlPoint[1].Color),   (float)KGETA(pControlPoint[2].Color),   (float)KGETA(pControlPoint[3].Color) );
                        
                        KMatrix mcolorr(        (float)KGETR(pControlPoint[12].Color),          (float)KGETR(pControlPoint[13].Color),  (float)KGETR(pControlPoint[14].Color),  (float)KGETR(pControlPoint[15].Color),
                                                                (float)KGETR(pControlPoint[8].Color),           (float)KGETR(pControlPoint[9].Color),   (float)KGETR(pControlPoint[10].Color),  (float)KGETR(pControlPoint[11].Color),
                                                                (float)KGETR(pControlPoint[4].Color),           (float)KGETR(pControlPoint[5].Color),   (float)KGETR(pControlPoint[6].Color),   (float)KGETR(pControlPoint[7].Color),
                                                                (float)KGETR(pControlPoint[0].Color),           (float)KGETR(pControlPoint[1].Color),   (float)KGETR(pControlPoint[2].Color),   (float)KGETR(pControlPoint[3].Color) );
                        
                        KMatrix mcolorg(        (float)KGETG(pControlPoint[12].Color),          (float)KGETG(pControlPoint[13].Color),  (float)KGETG(pControlPoint[14].Color),  (float)KGETG(pControlPoint[15].Color),
                                                                (float)KGETG(pControlPoint[8].Color),           (float)KGETG(pControlPoint[9].Color),   (float)KGETG(pControlPoint[10].Color),  (float)KGETG(pControlPoint[11].Color),
                                                                (float)KGETG(pControlPoint[4].Color),           (float)KGETG(pControlPoint[5].Color),   (float)KGETG(pControlPoint[6].Color),   (float)KGETG(pControlPoint[7].Color),
                                                                (float)KGETG(pControlPoint[0].Color),           (float)KGETG(pControlPoint[1].Color),   (float)KGETG(pControlPoint[2].Color),   (float)KGETG(pControlPoint[3].Color) );
                        
                        KMatrix mcolorb(        (float)KGETB(pControlPoint[12].Color),          (float)KGETB(pControlPoint[13].Color),  (float)KGETB(pControlPoint[14].Color),  (float)KGETB(pControlPoint[15].Color),
                                                                (float)KGETB(pControlPoint[8].Color),           (float)KGETB(pControlPoint[9].Color),   (float)KGETB(pControlPoint[10].Color),  (float)KGETB(pControlPoint[11].Color),
                                                                (float)KGETB(pControlPoint[4].Color),           (float)KGETB(pControlPoint[5].Color),   (float)KGETB(pControlPoint[6].Color),   (float)KGETB(pControlPoint[7].Color),
                                                                (float)KGETB(pControlPoint[0].Color),           (float)KGETB(pControlPoint[1].Color),   (float)KGETB(pControlPoint[2].Color),   (float)KGETB(pControlPoint[3].Color) );
                        
                        KMatrix mspecular(      (float)pControlPoint[12].Specular,      (float)pControlPoint[13].Specular,      (float)pControlPoint[14].Specular,      (float)pControlPoint[15].Specular,
                                                        (float)pControlPoint[8].Specular,               (float)pControlPoint[9].Specular,       (float)pControlPoint[10].Specular,      (float)pControlPoint[11].Specular,
                                                        (float)pControlPoint[4].Specular,               (float)pControlPoint[5].Specular,       (float)pControlPoint[6].Specular,       (float)pControlPoint[7].Specular,
                                                        (float)pControlPoint[0].Specular,               (float)pControlPoint[1].Specular,       (float)pControlPoint[2].Specular,       (float)pControlPoint[3].Specular );
                        
                        KMatrix         mu1(pControlPoint[12].tu1,      pControlPoint[13].tu1,  pControlPoint[14].tu1,  pControlPoint[15].tu1,
                                                        pControlPoint[8].tu1,   pControlPoint[9].tu1,   pControlPoint[10].tu1,  pControlPoint[11].tu1,
                                                        pControlPoint[4].tu1,   pControlPoint[5].tu1,   pControlPoint[6].tu1,   pControlPoint[7].tu1,
                                                        pControlPoint[0].tu1,   pControlPoint[1].tu1,   pControlPoint[2].tu1,   pControlPoint[3].tu1 );

                        KMatrix         mv1(pControlPoint[12].tv1,      pControlPoint[13].tv1,  pControlPoint[14].tv1,  pControlPoint[15].tv1,
                                                        pControlPoint[8].tv1,   pControlPoint[9].tv1,   pControlPoint[10].tv1,  pControlPoint[11].tv1,
                                                        pControlPoint[4].tv1,   pControlPoint[5].tv1,   pControlPoint[6].tv1,   pControlPoint[7].tv1,
                                                        pControlPoint[0].tv1,   pControlPoint[1].tv1,   pControlPoint[2].tv1,   pControlPoint[3].tv1 );

                        KMatrix         mu2(pControlPoint[12].tu2,      pControlPoint[13].tu2,  pControlPoint[14].tu2,  pControlPoint[15].tu2,
                                                        pControlPoint[8].tu2,   pControlPoint[9].tu2,   pControlPoint[10].tu2,  pControlPoint[11].tu2,
                                                        pControlPoint[4].tu2,   pControlPoint[5].tu2,   pControlPoint[6].tu2,   pControlPoint[7].tu2,
                                                        pControlPoint[0].tu2,   pControlPoint[1].tu2,   pControlPoint[2].tu2,   pControlPoint[3].tu2 );

                        KMatrix         mv2(pControlPoint[12].tv2,      pControlPoint[13].tv2,  pControlPoint[14].tv2,  pControlPoint[15].tv2,
                                                        pControlPoint[8].tv2,   pControlPoint[9].tv2,   pControlPoint[10].tv2,  pControlPoint[11].tv2,
                                                        pControlPoint[4].tv2,   pControlPoint[5].tv2,   pControlPoint[6].tv2,   pControlPoint[7].tv2,
                                                        pControlPoint[0].tv2,   pControlPoint[1].tv2,   pControlPoint[2].tv2,   pControlPoint[3].tv2 );

                        pV[y * n + x].Position.x        = (float)GetBezierPoint( s, t, mx );
                        pV[y * n + x].Position.y        = (float)GetBezierPoint( s, t, my );
                        pV[y * n + x].Position.z        = (float)GetBezierPoint( s, t, mz );
                        pV[y * n + x].Color                     = KRGBA( (u8)GetBezierPoint( s, t, mcolorr ), (u8)GetBezierPoint( s, t, mcolorg ), (u8)GetBezierPoint( s, t, mcolorb ), (u8)GetBezierPoint( s, t, mcolora ) );
                        pV[y * n + x].Specular          = (int)GetBezierPoint( s, t, mspecular );
                        pV[y * n + x].tu1                       = (float)GetBezierPoint( s, t, mu1 );
                        pV[y * n + x].tv1                       = (float)GetBezierPoint( s, t, mv1 );
                        pV[y * n + x].tu2                       = (float)GetBezierPoint( s, t, mu2 );
                        pV[y * n + x].tv2                       = (float)GetBezierPoint( s, t, mv2 );
                }

                // Genere les triangles
                // TODO : Utiliser des strips ou indexer tous ca
                for( u32 v = 0; v < n * n; v ++ )
                        m_pVertices[nVertex + v] = pV[v];
                
                for( y = 0; y < n - 1; y ++ )
                for( x = 0; x < n - 1; x ++ )
                {
                        m_pIndices[nIndices + 0]        = (u16)(nVertex + y * n + x);
                        m_pIndices[nIndices + 1]        = (u16)(nVertex + y * n + (x + 1));
                        m_pIndices[nIndices + 2]        = (u16)(nVertex + (y + 1) * n + x);
                        nIndices += 3;                          
                                                                                
                        m_pIndices[nIndices + 0]        = (u16)(nVertex + (y + 1) * n + x);
                        m_pIndices[nIndices + 1]        = (u16)(nVertex + y * n + (x + 1));
                        m_pIndices[nIndices + 2]        = (u16)(nVertex + (y + 1) * n + (x + 1));
                        nIndices += 3;
                }

                nVertex += n * n;
                Deletev( pV );
        }
}

//---------------------------------------------------------------------------------------------------------------------
double KBezierPatch::GetBezierPoint( double s, double t, KMatrix& m )
{
        return pow( 1 - s, 3 ) * ( m._11 * pow( 1 - t, 3 ) + 3 * m._21 * pow( 1 - t, 2 ) * t + 3 * m._31 * ( 1 - t ) * pow( t, 2 ) + m._41 * pow( t, 3 ) )
                        + 3 * pow( 1 - s, 2 ) * s * ( m._12 * pow( 1 - t, 3 ) + 3 * m._22 * pow( 1 - t, 2 ) * t + 3 * m._32 * ( 1 - t ) * pow( t, 2 ) + m._42 * pow( t, 3 ) )
                        + 3 * ( 1 - s ) * pow( s, 2 ) * ( m._13 * pow( 1 - t, 3 ) + 3 * m._23 * pow( 1 - t, 2 ) * t + 3 * m._33 * ( 1 - t ) * pow( t, 2 ) + m._43 * pow( t, 3 ) )
                        + pow( s, 3 ) * ( m._14 * pow( 1 - t, 3 ) + 3 * m._24 * pow( 1 - t, 2 ) * t + 3 * m._34 * ( 1 - t ) * pow( t, 2 ) + m._44 * pow( t, 3 ) );
}

---