Camera3D.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of HPL1 Engine.
 */

#ifndef HPL_CAMERA3D_H
#define HPL_CAMERA3D_H

#include "hpl1/engine/math/Frustum.h"
#include "hpl1/engine/math/MathTypes.h"
#include "hpl1/engine/scene/Camera.h"
#include "hpl1/engine/scene/Node3D.h"

namespace hpl {

enum eCameraMoveMode {
    eCameraMoveMode_Walk,
    eCameraMoveMode_Fly,
    eCameraMoveMode_LastEnum
};

enum eCameraRotateMode {
    eCameraRotateMode_EulerAngles,
    eCameraRotateMode_Matrix,
    eCameraRotateMode_LastEnum
};

class iLowLevelGraphics;
class iEntity3D;

class cCamera3D : public iCamera {
public:
    cCamera3D();
    virtual ~cCamera3D();

    const cVector3f &GetPosition() const { return mvPosition; }
    void SetPosition(const cVector3f &avPos);

    void MoveForward(float afDist);
    void MoveRight(float afDist);
    void MoveUp(float afDist);

    void SetFOV(float afAngle) {
        mfFOV = afAngle;
        mbProjectionUpdated = true;
    }
    float GetFOV() { return mfFOV; }

    void SetAspect(float afAngle) {
        mfAspect = afAngle;
        mbProjectionUpdated = true;
    }
    float GetAspect() { return mfAspect; }

    void SetFarClipPlane(float afX) {
        mfFarClipPlane = afX;
        mbProjectionUpdated = true;
    }
    float GetFarClipPlane() { return mfFarClipPlane; }

    void SetNearClipPlane(float afX) {
        mfNearClipPlane = afX;
        mbProjectionUpdated = true;
    }
    float GetNearClipPlane() { return mfNearClipPlane; }

    void SetInifintiveFarPlane(bool abX) {
        mbInfFarPlane = abX;
        mbProjectionUpdated = true;
    }
    bool GetInifintiveFarPlane() { return mbInfFarPlane; }

    cFrustum *GetFrustum();

    eCameraRotateMode GetRotateMode() { return mRotateMode; }

    eCameraMoveMode GetMoveMode() { return mMoveMode; }
    void SetRotateMode(eCameraRotateMode aMode);
    void SetMoveMode(eCameraMoveMode aMode);

    void ResetRotation();

    cVector3f UnProject(const cVector2f &avScreenPos, iLowLevelGraphics *apLowLevel);

    void AttachEntity(iEntity3D *apEntity);
    void RemoveEntity(iEntity3D *apEntity);
    cNode3D *GetAttachmentNode() { return &mNode; }
    void ClearAttachedEntities();


    void SetPitch(float afAngle);
    void SetYaw(float afAngle);
    void SetRoll(float afAngle);

    void AddPitch(float afAngle);
    void AddYaw(float afAngle);
    void AddRoll(float afAngle);

    float GetPitch() const { return mfPitch; }
    float GetYaw() const { return mfYaw; }
    float GetRoll() const { return mfRoll; }

    void SetPitchLimits(cVector2f avLimits) { mvPitchLimits = avLimits; }
    const cVector2f &GetPitchLimits() { return mvPitchLimits; }
    void SetYawLimits(cVector2f avLimits) { mvYawLimits = avLimits; }
    const cVector2f &GetYawLimits() { return mvYawLimits; }


    const cMatrixf &GetViewMatrix();
    const cMatrixf &GetProjectionMatrix();

    const cMatrixf &GetMoveMatrix();

    // iCamera stuff:
    void SetModelViewMatrix(iLowLevelGraphics *apLowLevel);
    void SetProjectionMatrix(iLowLevelGraphics *apLowLevel);
    cVector3f GetEyePosition();

    eCameraType GetType() { return eCameraType_3D; }

    cVector3f GetForward();
    cVector3f GetRight();
    cVector3f GetUp();


    void SetPrevView(const cMatrixf &a_mtxA) { m_mtxPrevView = a_mtxA; }
    void SetPrevProjection(const cMatrixf &a_mtxA) { m_mtxPrevProjection = a_mtxA; }

    cMatrixf &GetPrevView() { return m_mtxPrevView; }
    cMatrixf &GetPrevProjection() { return m_mtxPrevProjection; }

private:
    void UpdateMoveMatrix();

    cVector3f mvPosition;

    float mfFOV;
    float mfAspect;
    float mfFarClipPlane;
    float mfNearClipPlane;

    float mfPitch;
    float mfYaw;
    float mfRoll;
    cVector2f mvPitchLimits;
    cVector2f mvYawLimits;

    eCameraRotateMode mRotateMode;
    eCameraMoveMode mMoveMode;

    cMatrixf m_mtxView;
    cMatrixf m_mtxProjection;
    cMatrixf m_mtxMove;

    cMatrixf m_mtxPrevView;
    cMatrixf m_mtxPrevProjection;

    cNode3D mNode;

    cFrustum mFrustum;

    bool mbInfFarPlane;

    bool mbViewUpdated;
    bool mbProjectionUpdated;
    bool mbMoveUpdated;
};

} // namespace hpl

#endif // HPL_CAMERA3D_H