mgcgpcamera.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
//
// RESTRICTED USE SOURCE CODE
// http://www.magic-software.com/License/restricted.pdf

#include "MgcGPCamera.h"

MgcImplementRTTI(MgcGPCamera,MgcCamera);
MgcImplementStream(MgcGPCamera);

//----------------------------------------------------------------------------
MgcGPCamera::MgcGPCamera (MgcReal fWidth, MgcReal fHeight)
{
    m_fWidth = fWidth;
    m_fHeight = fHeight;

    OnFrustumChange();
    OnViewPortChange();
    OnFrameChange();
}
//----------------------------------------------------------------------------
MgcGPCamera::MgcGPCamera ()
{
}
//----------------------------------------------------------------------------
void MgcGPCamera::OnFrustumChange ()
{
    MgcCamera::OnFrustumChange();

    m_fInverseNear = 1.0/m_fFrustumN;
    m_fFarDivideNear = m_fFrustumF/m_fFrustumN;
    m_fFarDivideFarMinusNear = m_fFrustumF/(m_fFrustumF - m_fFrustumN);
    m_fTwoDivRmL = 2.0/(m_fFrustumR - m_fFrustumL);
    m_fRpLDivNRmL = 0.5*m_fTwoDivRmL*m_fInverseNear*(m_fFrustumR+m_fFrustumL);
    m_fTwoDivTmB = 2.0/(m_fFrustumT - m_fFrustumB);
    m_fTpBDivNTmB = 0.5*m_fTwoDivTmB*m_fInverseNear*(m_fFrustumT+m_fFrustumB);

    UpdateProjRotMatrix();
}
//----------------------------------------------------------------------------
void MgcGPCamera::OnViewPortChange ()
{
    MgcCamera::OnViewPortChange();

    // set view port
    m_iPortL = int(m_fPortL*m_fWidth);
    m_iPortB = int(m_fPortB*m_fHeight);
    m_iPortW = int((m_fPortR - m_fPortL)*m_fWidth);
    m_iPortH = int((m_fPortT - m_fPortB)*m_fHeight);
}
//----------------------------------------------------------------------------
void MgcGPCamera::OnFrameChange ()
{
    MgcCamera::OnFrameChange();
    UpdateProjRotMatrix();
}
//----------------------------------------------------------------------------
void MgcGPCamera::UpdateProjRotMatrix ()
{
    m_kProjRot[0][0] = m_fTwoDivRmL*m_kLeft[0]-m_fRpLDivNRmL*m_kDirection[0];
    m_kProjRot[0][1] = m_fTwoDivRmL*m_kLeft[1]-m_fRpLDivNRmL*m_kDirection[1];
    m_kProjRot[0][2] = m_fTwoDivRmL*m_kLeft[2]-m_fRpLDivNRmL*m_kDirection[2];
    m_kProjRot[1][0] = m_fTwoDivTmB*m_kUp[0] - m_fTpBDivNTmB*m_kDirection[0];
    m_kProjRot[1][1] = m_fTwoDivTmB*m_kUp[1] - m_fTpBDivNTmB*m_kDirection[1];
    m_kProjRot[1][2] = m_fTwoDivTmB*m_kUp[2] - m_fTpBDivNTmB*m_kDirection[2];
    m_kProjRot[2][0] = m_fInverseNear*m_kDirection[0];
    m_kProjRot[2][1] = m_fInverseNear*m_kDirection[1];
    m_kProjRot[2][2] = m_fInverseNear*m_kDirection[2];
}
//----------------------------------------------------------------------------
void MgcGPCamera::ComputeModelToViewTransform (const MgcMatrix3& rkWRot,
    const MgcVector3& rkWTrn, MgcReal fWScale, MgcMatrix3& rkModelToViewMat,
    MgcVector3& rkModelToViewTrn)
{
    rkModelToViewTrn = m_kProjRot*(rkWTrn - m_kLocation);
    rkModelToViewMat = (m_kProjRot*rkWRot)*fWScale;
}
//----------------------------------------------------------------------------

//---------------------------------------------------------------------------
// streaming
//---------------------------------------------------------------------------
MgcObject* MgcGPCamera::Factory (MgcStream& rkStream)
{
    MgcGPCamera* pkObject = new MgcGPCamera;
    MgcStream::Link* pkLink = new MgcStream::Link(pkObject);
    pkObject->Load(rkStream,pkLink);
    return pkObject;
}
//---------------------------------------------------------------------------
void MgcGPCamera::Load (MgcStream& rkStream, MgcStream::Link* pkLink)
{
    MgcCamera::Load(rkStream,pkLink);
}
//---------------------------------------------------------------------------
void MgcGPCamera::Link (MgcStream& rkStream, MgcStream::Link* pkLink)
{
    MgcCamera::Link(rkStream,pkLink);
}
//---------------------------------------------------------------------------
bool MgcGPCamera::Register (MgcStream& rkStream)
{
    return MgcCamera::Register(rkStream);
}
//---------------------------------------------------------------------------
void MgcGPCamera::Save (MgcStream& rkStream)
{
    MgcCamera::Save(rkStream);
}
//---------------------------------------------------------------------------