testcurve.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
//
// FREE SOURCE CODE
// http://www.magic-software.com/License.html/free.pdf

#include "TestCurve.h"

//---------------------------------------------------------------------------
MgcApplication* MgcApplication::Create ()
{
    return new TestCurve;
}
//---------------------------------------------------------------------------
TestCurve::TestCurve ()
    :
    MgcApplication("TestCurve",256,256)
{
    m_pkCurve = 0;
}
//---------------------------------------------------------------------------
bool TestCurve::Initialize ()
{
#if 0
    const int iDegree = 3;
    MgcVector2* akCtrlPoint = new MgcVector2[iDegree+1];
    akCtrlPoint[0].x = 16.0;
    akCtrlPoint[0].y = 128.0;
    akCtrlPoint[1].x = 96.0;
    akCtrlPoint[1].y = 224.0;
    akCtrlPoint[2].x = 160.0;
    akCtrlPoint[2].y = 32.0;
    akCtrlPoint[3].x = 240.0;
    akCtrlPoint[3].y = 128.0;
    m_pkCurve = new MgcBezierCurve2(iDegree,akCtrlPoint);
#endif

#if 0
    const int iSegments = 4;
    MgcReal* afTime = new MgcReal[iSegments+1];
    afTime[0] = 0.0;
    afTime[1] = 0.25;
    afTime[2] = 0.50;
    afTime[3] = 0.75;
    afTime[4] = 1.00;
    MgcVector2* akPoint = new MgcVector2[iSegments+1];
    akPoint[0].x = 16.0;
    akPoint[0].y = 128.0;
    akPoint[1].x = 96.0;
    akPoint[1].y = 224.0;
    akPoint[2].x = 160.0;
    akPoint[2].y = 32.0;
    akPoint[3].x = 240.0;
    akPoint[3].y = 128.0;
    akPoint[4].x = 16.0;
    akPoint[4].y = 128.0;
    m_pkCurve = new MgcNaturalSpline2(MgcNaturalSpline2::BT_CLOSED,
        iSegments,afTime,akPoint);
#endif

    const int iSegments = 3;

    MgcReal* afTime = new MgcReal[iSegments+1];
    afTime[0] = 0.0;
    afTime[1] = 0.33;
    afTime[2] = 0.67;
    afTime[3] = 1.00;

    MgcVector2* akPoint = new MgcVector2[iSegments+1];
    akPoint[0].x = 16.0;
    akPoint[0].y = 128.0;
    akPoint[1].x = 96.0;
    akPoint[1].y = 224.0;
    akPoint[2].x = 160.0;
    akPoint[2].y = 32.0;
    akPoint[3].x = 240.0;
    akPoint[3].y = 128.0;

    MgcReal* afTension = new MgcReal[iSegments+1];
    MgcReal* afContinuity = new MgcReal[iSegments+1];
    MgcReal* afBias = new MgcReal[iSegments+1];
    memset(afTension,0,(iSegments+1)*sizeof(MgcReal));
    memset(afContinuity,0,(iSegments+1)*sizeof(MgcReal));
    memset(afBias,0,(iSegments+1)*sizeof(MgcReal));

    m_pkCurve = new MgcTCBSpline2(iSegments,afTime,akPoint,afTension,
        afContinuity,afBias);

    InvalidateRect(GetWindowHandle(),NULL,true);

    return true;
}
//---------------------------------------------------------------------------
void TestCurve::Terminate ()
{
    delete m_pkCurve;
}
//---------------------------------------------------------------------------
bool TestCurve::WmPaint (HDC hDC)
{
    if ( !m_pkCurve )
        return false;

    // draw ctrl points
#if 0
    int iDegree = m_pkCurve->GetDegree();
    const MgcVector2* akCtrlPoint = m_pkCurve->GetControlPoints();
    int i;
    for (i = 0; i <= iDegree; i++)
    {
        int iX = akCtrlPoint[i].x;
        int iY = akCtrlPoint[i].y;
        for (int iDy = -2; iDy <= 2; iDy++)
        {
            for (int iDx = -2; iDx <= 2; iDx++)
                SetPixel(hDC,iX+iDx,iY+iDy,RGB(0,0,0));
        }
    }
    MgcVector2 kPos;
#endif

#if 0
    int iSegments = m_pkCurve->GetSegments();
    const MgcVector2* akPoint = m_pkCurve->GetPoints();
    int i;
    for (i = 0; i <= iSegments; i++)
    {
        int iX = akPoint[i].x;
        int iY = akPoint[i].y;
        for (int iDy = -2; iDy <= 2; iDy++)
        {
            for (int iDx = -2; iDx <= 2; iDx++)
                SetPixel(hDC,iX+iDx,iY+iDy,RGB(0,0,0));
        }
    }
    MgcVector2 kPos;
#endif

    int iSegments = m_pkCurve->GetSegments();
    const MgcVector2* akPoint = m_pkCurve->GetPoints();
    int i;
    for (i = 0; i <= iSegments; i++)
    {
        int iX = akPoint[i].x;
        int iY = akPoint[i].y;
        for (int iDy = -2; iDy <= 2; iDy++)
        {
            for (int iDx = -2; iDx <= 2; iDx++)
                SetPixel(hDC,iX+iDx,iY+iDy,RGB(0,0,0));
        }
    }
    MgcVector2 kPos;

    // draw curve
    HPEN hPen = CreatePen(PS_SOLID,1,RGB(0,0,255));
    HGDIOBJ hOldPen = SelectObject(hDC,hPen);

    kPos = m_pkCurve->GetPosition(0.0);
    MoveToEx(hDC,(int)kPos.x,(int)kPos.y,NULL);
    int iMax = 1024;
    for (i = 1; i <= iMax; i++)
    {
        MgcReal fTime = i/MgcReal(iMax);
        kPos = m_pkCurve->GetPosition(fTime);
        LineTo(hDC,(int)kPos.x,(int)kPos.y);
    }

    SelectObject(hDC,hOldPen);
    DeleteObject(hPen);
    
    return true;
}
//---------------------------------------------------------------------------
bool TestCurve::WmChar (char cCharCode, long lKeyData)
{
    switch ( cCharCode )
    {
    case 'q':
    case 'Q':
    case VK_ESCAPE:
        PostMessage(GetWindowHandle(),WM_DESTROY,0,0);
        return true;
    }

    return false;
}
//---------------------------------------------------------------------------