testintersections.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 "TestIntersections.h"

//---------------------------------------------------------------------------
MgcApplication* MgcApplication::Create ()
{
    return new TestIntersections;
}
//---------------------------------------------------------------------------
TestIntersections::TestIntersections ()
    :
    MgcApplication("TestIntersections",640,480,0,1)
{
    // set up bindings for camera turret
    m_fTrnSpeed = 1.0;
    m_fRotSpeed = 0.1;
    m_kTurret.BindKeysToTranslateRight('[',']',m_fTrnSpeed);
    m_kTurret.BindKeysToTranslateUp('{','}',m_fTrnSpeed);
    m_kTurret.BindKeysToTranslateDirection(VK_DOWN,VK_UP,m_fTrnSpeed);
    m_kTurret.BindKeysToRotateRight(VK_PRIOR,VK_NEXT,0.1*m_fRotSpeed);
    m_kTurret.BindKeysToRotateUp(VK_RIGHT,VK_LEFT,0.1*m_fRotSpeed);

    // initialize 'last time'
    MeasureTime();
}
//---------------------------------------------------------------------------
bool TestIntersections::Initialize ()
{
    m_spkCamera = new MgcOglCamera(640,480);
    m_spkCamera->SetFrustum(1.0,1000.0,-0.55,0.55,0.4125,-0.4125);
    m_spkRenderer = new MgcOglRenderer(GetWindowHandle(),640,480);
    m_spkRenderer->SetBackgroundColor(MgcColor(0.5f,0.0f,1.0f));
    m_spkRenderer->SetCamera(m_spkCamera);

    unsigned int* auiData = new unsigned int[32*32];
    for (unsigned int uiI = 0; uiI < 32*32; uiI++)
    {
        auiData[uiI] =
            (rand() % 256) |
            ((rand() % 256) << 8) |
            ((rand() % 256) << 16) |
            (0xFF << 24);
    }
    MgcImage* pkImage = new MgcImage(MgcImage::IT_RGBA8888,32,32,
        (unsigned char*)auiData);

    m_spkTexture0 = new MgcTexture;
    m_spkTexture0->SetImage(pkImage);
    m_spkTexture0->Mipmap() = MgcTexture::MM_LINEAR_LINEAR;
    m_spkTextureState = new MgcTextureState;
    m_spkTextureState->Set(0,m_spkTexture0);

    // Scene --+-- DepthNode --+-- Line
    //         |               |
    //         |               +-- Cube0
    //         |               |
    //         |               +-- Cube1
    //         |
    //         +-- Cylinder

    m_spkScene = new MgcNode;
    MgcNode* pkDepthNode = new MgcNode;
    m_spkScene->AttachChild(pkDepthNode);

    m_spkCyln = CreateCylinder();
    m_spkScene->AttachChild(m_spkCyln);

    m_spkLine = CreateLine();
    m_spkLine->Scale() = 16.0;
    pkDepthNode->AttachChild(m_spkLine);

    m_spkCube[0] = CreateColoredCube();
    m_spkCube[0]->Scale() = 0.05;
    pkDepthNode->AttachChild(m_spkCube[0]);

    m_spkCube[1] = CreateColoredCube();
    m_spkCube[1]->Scale() = 0.05;
    pkDepthNode->AttachChild(m_spkCube[1]);

    m_pObject = m_spkScene;

    int iQuantity;
    MgcVector3 akPoint[2];
    //MgcFindIntersection(m_kLine,m_kCyln,iQuantity,akPoint);
    MgcFindIntersection(m_kLine,m_kCapsule,iQuantity,akPoint);

    int i;
    for (i = 0; i < iQuantity; i++)
    {
        m_spkCube[i]->Translate() = akPoint[i];
        m_spkCube[i]->ForceCull() = false;
    }
    for (i = iQuantity; i < 2; i++)
    {
        m_spkCube[i]->ForceCull() = true;
    }

    // render states
    m_spkFogState = new MgcFogState;
    m_spkScene->SetRenderState(m_spkFogState);

    m_spkWireframeState = new MgcWireframeState;
    m_spkScene->SetRenderState(m_spkWireframeState);

    m_spkZBufferState = new MgcZBufferState;
    m_spkZBufferState->Enabled() = true;
    m_spkZBufferState->Writeable() = true;
    m_spkZBufferState->Compare() = MgcZBufferState::CF_LEQUAL;
    pkDepthNode->SetRenderState(m_spkZBufferState);


#if 0
    m_spkDLight = new MgcDirectionalLight;
    m_spkDLight->Ambient() = MgcColor(1.0,1.0,1.0);
    m_spkDLight->Diffuse() = MgcColor(1.0,1.0,1.0);
    m_spkLightState = new MgcLightState;
    m_spkLightState->Attach(m_spkDLight);
    m_spkScene->SetRenderState(m_spkLightState);
#endif

    m_spkCamera->Update();
    m_spkScene->UpdateGS(0.0);
    m_spkScene->UpdateRS();
    return true;
}
//---------------------------------------------------------------------------
void TestIntersections::Terminate ()
{
    m_spkCyln = 0;
    m_spkLine = 0;
    m_spkCube[0] = 0;
    m_spkCube[1] = 0;

    m_spkDLight = 0;
    m_spkTexture0 = 0;

    m_spkFogState = 0;
    m_spkLightState = 0;
    m_spkTextureState = 0;
    m_spkWireframeState = 0;
    m_spkZBufferState = 0;
    m_spkRenderer = 0;
    m_spkScene = 0;
}
//---------------------------------------------------------------------------
void TestIntersections::OnIdle ()
{
    MeasureTime();

    if ( GetFocus() == GetWindowHandle() )
    {
        if ( m_kTurret.ReadKeyboard() )
        {
            m_spkRenderer->GetCamera()->SetFrame(m_kTurret.GetTranslate(),
                m_kTurret.GetRotate());
        }
    }

    m_spkRenderer->ClearBuffers();
    m_spkRenderer->Draw(m_spkScene);
    m_spkRenderer->DisplayBackBuffer();

    DrawFrameRate();
    UpdateClicks();
}
//---------------------------------------------------------------------------
void TestIntersections::UpdateIntersection ()
{
    if ( m_pObject == m_spkLine )
    {
        m_kLine.Origin() = m_spkLine->Translate();
        m_kLine.Direction() = 2.0*m_spkLine->Rotate().GetColumn(2);
    }
    else if ( m_pObject == m_spkCyln )
    {
        m_kCyln.Center() = m_spkCyln->Translate();
        m_kCyln.Direction() = m_spkCyln->Rotate().GetColumn(2);
        m_kCapsule.Origin() = m_spkCyln->Translate();
        m_kCapsule.Direction() = m_spkCyln->Rotate().GetColumn(2);
    }
    else
    {
        return;
    }

    int iQuantity;
    MgcVector3 akPoint[2];
    //MgcFindIntersection(m_kLine,m_kCyln,iQuantity,akPoint);
    MgcFindIntersection(m_kLine,m_kCapsule,iQuantity,akPoint);

    int i;
    for (i = 0; i < iQuantity; i++)
    {
        m_spkCube[i]->Translate() = akPoint[i];
        m_spkCube[i]->ForceCull() = false;
        m_spkCube[i]->UpdateGS(m_fLastTime);
    }

    for (i = iQuantity; i < 2; i++)
        m_spkCube[i]->ForceCull() = true;
}
//---------------------------------------------------------------------------
bool TestIntersections::Transform (char cCharCode, long lKeyData)
{
    MgcVector3 trn;
    MgcMatrix3 rot, incr;

    static MgcReal fTime = 0.0;

    switch ( cCharCode )
    {
        case 'g':
            fTime += 0.01;
            break;
        case 'G':
            fTime = 0.0;
            break;
        case 'c':
            if ( m_pObject == m_spkLine )
            {
                m_pObject = m_spkCyln;
                return true;
            }
            if ( m_pObject == m_spkCyln )
            {
                m_pObject = m_spkScene;
                return true;
            }
            if ( m_pObject == m_spkScene )
            {
                m_pObject = m_spkLine;
                return true;
            }
            break;
        case 'x':
            m_pObject->Translate().x -= m_fTrnSpeed;
            break;
        case 'X':
            m_pObject->Translate().x += m_fTrnSpeed;
            break;
        case 'y':
            m_pObject->Translate().y -= m_fTrnSpeed;
            break;
        case 'Y':
            m_pObject->Translate().y += m_fTrnSpeed;
            break;
        case 'z':
            m_pObject->Translate().z -= m_fTrnSpeed;
            break;
        case 'Z':
            m_pObject->Translate().z += m_fTrnSpeed;
            break;
        case 'r':
            rot = m_pObject->Rotate();
            incr.FromAxisAngle(MgcVector3::UNIT_X,m_fRotSpeed);
            m_pObject->Rotate() = incr*rot;
            break;
        case 'R':
            rot = m_pObject->Rotate();
            incr.FromAxisAngle(MgcVector3::UNIT_X,-m_fRotSpeed);
            m_pObject->Rotate() = incr*rot;
            break;
        case 'a':
            rot = m_pObject->Rotate();
            incr.FromAxisAngle(MgcVector3::UNIT_Y,m_fRotSpeed);
            m_pObject->Rotate() = incr*rot;
            break;
        case 'A':
            rot = m_pObject->Rotate();
            incr.FromAxisAngle(MgcVector3::UNIT_Y,-m_fRotSpeed);
            m_pObject->Rotate() = incr*rot;
            break;
        case 'p':
            rot = m_pObject->Rotate();
            incr.FromAxisAngle(MgcVector3::UNIT_Z,m_fRotSpeed);
            m_pObject->Rotate() = incr*rot;
            break;
        case 'P':
            rot = m_pObject->Rotate();
            incr.FromAxisAngle(MgcVector3::UNIT_Z,-m_fRotSpeed);
            m_pObject->Rotate() = incr*rot;
            break;
        default:
            return false;
    }

    m_pObject->UpdateGS(fTime);
    UpdateIntersection();
    return true;
}
//---------------------------------------------------------------------------
bool TestIntersections::WmChar (char cCharCode, long lKeyData)
{
    if ( Transform(cCharCode,lKeyData) )
        return true;

    switch ( cCharCode )
    {
    case '0':  // reset frame rate measurements
        ResetTime();
        return true;
    case 'b':
        m_spkZBufferState->Enabled() = !m_spkZBufferState->Enabled();
        return true;