3D中的相机 - 投影矩阵和视图矩阵

3D中的相机 - 投影矩阵和视图矩阵
3d游戏中，一般通过相机的设置来计算投影矩阵和视图矩阵，比如untiy和cocos，一般情况下我们不用关注如何计算，
可以直接在可视化的编辑器中调整参数就可以了,但是了解下总是好的。
具体计算可以参考：
可以参考现在cocos2dx的代码中的Camera源码，里面有根据相机的设置（位置等）计算上面两个矩阵的代码。
也可以参考下面这个，github上面一个项目，这个项目有很好的参考价值：
https://github.com/wantnon2/3DToolKit-2-for-cocos2dx/blob/master/c3dToolKit/core/c3dCamera.h
```
//
//  c3dCamera.h
//  HelloCpp
//
//  Created by Yang Chao (wantnon) on 14-1-7.
//
//
#ifndef __HelloCpp__c3dCamera__
#define __HelloCpp__c3dCamera__

#include <iostream>
using namespace std;
#include "cocos2d.h"
using namespace cocos2d;
#include "c3dVector.h"
#include "c3dMatrix.h"
#include "c3dGLMath.h"
#include "c3dCommonFunc.h"
#include "c3dMatrixStackInfoGetor.h"
#include "c3dRange.h"
class Cc3dCamera:public CCCamera
{
public:
    Cc3dCamera(){
        CCSize winSize=CCDirector::sharedDirector()->getWinSize();
        m_fovy=;
        m_aspect=winSize.width/winSize.height;
        m_zNear=;//554/2;//0.5;
        m_zFar=;

        const float w=winSize.width;//11;
        const float h=winSize.height;//w*winSize.height/winSize.width;
        m_range.init(-w/, -w/+w, -h/, -h/+h,
                     -,//yeah, better to use negative value
                     );
        m_projectionMode=ec3dPerspectiveMode;
        m_isViewMatDirty=false;
        m_isViewMatInverseDirty=false;

    }
    virtual ~Cc3dCamera(){

    }

    Cc3dVector4 getEyePos()const;
    Cc3dVector4 getCenter()const;
    Cc3dVector4 getUp()const;
    void setEyePos(const Cc3dVector4&eyePos);
    void setCenter(const Cc3dVector4&center);
    void setUp(const Cc3dVector4&up);
    float getFovy()const {return m_fovy;}
    float getAspect()const {return m_aspect;}
    float getzNear()const {return m_zNear;}
    float getzFar()const {return m_zFar;}
    void setFovy(float fovy){m_fovy=fovy;}
    void setAspect(float aspect){m_aspect=aspect;}
    void setzNear(float zNear){m_zNear=zNear;}
    void setzFar(float zFar){m_zFar=zFar;}
    Cc3dRange getRange()const {return m_range;}
    void setRange(const Cc3dRange&range){m_range=range;}
    Cc3dMatrix4 calculateViewMat();
    Cc3dMatrix4 calculateViewMatInverse();
    Cc3dMatrix4 calculateProjectionMat();
    Ec3dProjectionMode getProjectionMode(){return m_projectionMode;}
    void setProjectionMode(Ec3dProjectionMode projectionMode){m_projectionMode=projectionMode;}
    void applyProjection();
    void printProjectionMode()const;
protected:
    //projection mode type
    Ec3dProjectionMode m_projectionMode;
    //perspective projection mode params
    float m_fovy;
    float m_aspect;
    float m_zNear;
    float m_zFar;
    //Ortho projection mode params
    Cc3dRange m_range;//in the camera space
protected:
    //cache viewMat
    Cc3dMatrix4 m_viewMatCache;
    bool m_isViewMatDirty;
    Cc3dMatrix4 m_viewMatInverseCache;
    bool m_isViewMatInverseDirty;

};
#endif /* defined(__HelloCpp__c3dCamera__) */

//
//  c3dCamera.cpp
//  HelloCpp
//
//  Created by Yang Chao (wantnon) on 14-1-7.
//
//

#include "c3dCamera.h"

Cc3dVector4 Cc3dCamera::getEyePos()const{
    //getEyeXYZ is not const, but i want getEyePos to be const
    //so i convert this from const to nonconst
    float eyex,eyey,eyez;
    ((Cc3dCamera*)this)->getEyeXYZ(&eyex, &eyey, &eyez);
    return Cc3dVector4(eyex,eyey,eyez,);
}
Cc3dVector4 Cc3dCamera::getCenter()const{
    //getCenterXYZ is not const, but i want getCenter to be const
    //so i convert this from const to nonconst
    float centerX,centerY,centerZ;
    ((Cc3dCamera*)this)->getCenterXYZ(&centerX, &centerY, &centerZ);
    return Cc3dVector4(centerX,centerY,centerZ,);
}
Cc3dVector4 Cc3dCamera::getUp()const{
    //getUpXYZ is not const, but i want getUp to be const
    //so i convert this from const to nonconst
    float upX,upY,upZ;
    ((Cc3dCamera*)this)->getUpXYZ(&upX, &upY, &upZ);
    return Cc3dVector4(upX,upY,upZ,);
}
void Cc3dCamera::setEyePos(const Cc3dVector4&eyePos){
    this->setEyeXYZ(eyePos.x(), eyePos.y(), eyePos.z());
    m_isViewMatDirty=true;
    m_isViewMatInverseDirty=true;

}
void Cc3dCamera::setCenter(const Cc3dVector4&center){
    this->setCenterXYZ(center.x(), center.y(), center.z());
    m_isViewMatDirty=true;
    m_isViewMatInverseDirty=true;

}
void Cc3dCamera::setUp(const Cc3dVector4&up){
    this->setUpXYZ(up.x(), up.y(), up.z());
    m_isViewMatDirty=true;
    m_isViewMatInverseDirty=true;
}

Cc3dMatrix4 Cc3dCamera::calculateViewMat(){
    //why we not just return CCCamera::m_lookupMatrix?
    //because m_lookupMatrix may be dirty (m_lookupMatrix got updated only when locate is called)
    //so we calculate view matrix ourselves.
    Cc3dMatrix4 ret;
    if(m_isViewMatDirty){//dirty
        //calculate and cache
        ret=::calculateViewMatrix(getEyePos(), getCenter(), getUp());
        m_viewMatCache=ret;
    }else{//not dirty
        //get from cache
        ret=m_viewMatCache;
    }
    return ret;

};
Cc3dMatrix4 Cc3dCamera::calculateViewMatInverse(){
    Cc3dMatrix4 ret;
    if(m_isViewMatInverseDirty){
        ret=::calculateViewMatrixInverse(getEyePos(), getCenter(), getUp());
        m_viewMatInverseCache=ret;
    }else{
        ret=m_viewMatInverseCache;
    }
    return ret;
}
Cc3dMatrix4 Cc3dCamera::calculateProjectionMat(){
    Cc3dMatrix4 projectionMat;
    switch (m_projectionMode) {
        case ec3dPerspectiveMode:
            projectionMat=::calculatePerspectiveProjectionMatrix(m_fovy, m_aspect, m_zNear, m_zFar);
            break;
        case ec3dOrthographicMode:
            projectionMat=::calculateOrthoProjectionMatrix(m_range.getMinX(), m_range.getMaxX(), m_range.getMinY(), m_range.getMaxY(), m_range.getMinZ(), m_range.getMaxZ());
            break;
        default:
            assert(false);
            break;
    }
    return projectionMat;
}
void Cc3dCamera::applyProjection()
//note: after apply projection matrix, will be back to modelview matrix stack
{
    Cc3dMatrix4 projectionMat=calculateProjectionMat();
    kmGLMatrixMode(KM_GL_PROJECTION);
    kmGLLoadIdentity();
    kmMat4 projMat;
    memcpy(projMat.mat, projectionMat.getArray(), *sizeof(float));
    kmGLMultMatrix(&projMat);
    //restore to model view stack
    kmGLMatrixMode(KM_GL_MODELVIEW);

};
void Cc3dCamera::printProjectionMode()const{
    if(m_projectionMode==ec3dPerspectiveMode){
        C3DLOG("projectionMode: perspectiveMode");
    }else if(m_projectionMode==ec3dOrthographicMode){
        C3DLOG("projectionMode: orthographic");
    }else{
        assert(false);
    }
}
```