camera.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/>.
 *
 */

#ifndef TITANIC_CAMERA_H
#define TITANIC_CAMERA_H

#include "titanic/star_control/fmatrix.h"
#include "titanic/star_control/base_stars.h"
#include "titanic/star_control/viewport.h"

namespace Titanic {

class CMotionControl;
class CErrorCode;
struct CNavigationInfo;
class FPoint;
class SimpleFile;

enum StarLockLevel { ZERO_LOCKED=0, ONE_LOCKED=1, TWO_LOCKED=2, THREE_LOCKED=3 };

class CCamera {
private:
    static FMatrix *_priorOrientation;
    static FMatrix *_newOrientation;
private:
    StarLockLevel _lockLevel;
    FMatrix _lockedStarsPos; // Each row represents the location of a locked star
    CMotionControl *_motion; // A marked or unmarked camera mover, contains an automover
    CViewport _viewport;
    bool _isMoved; // Used in CPetStarfield to determine if a star destination can be set
    bool _isInLockingProcess; // The mover/view is homing in on a new star
private:
    bool createMotionControl(const CNavigationInfo *src);

    void deleteMotionController();

    bool isLocked();
public:
    static void init();
    static void deinit();
public:
    CCamera(const CNavigationInfo *data);
    CCamera(CViewport *src);
    virtual ~CCamera();

    virtual void setViewport(const CViewport *src);

    virtual void setMotion(const CNavigationInfo *src);

    bool isNotInLockingProcess();

    virtual void setPosition(const FVector &v);

    virtual void setOrientation(const FVector &v);

    virtual void setRoleAngle(double angle);

    virtual void setFrontClip(double n);

    virtual void SetBackClip(double f);

    virtual void setCenterYAngle(int v);
    virtual void setCenterZAngle(int v);
    virtual void randomizeOrientation();
    virtual void setFields(StarMode mode, double val);

    virtual void setDestination(const FVector &v);

    virtual void updatePosition(CErrorCode *errorCode);

    virtual void accelerate();

    virtual void deccelerate();

    virtual void fullSpeed();

    virtual void stop();

    virtual void reposition(double factor);

    virtual void setPosition(const FPose &pose);

    virtual void changeOrientation(FMatrix &m);

    virtual FPose getPose();

    virtual FPose getRawPose();

    virtual double getFrontClip() const;

    virtual double getBackClip() const;


    virtual StarColor getStarColor() const;

    virtual FVector getRelativePos(int index, const FVector &src);

    virtual FVector getRelativePosNoCentering(int index, const FVector &src);
    virtual FVector getRelativePosCentering(int index, const FVector &v);
    virtual FVector getRelativePosCenteringRaw(int index, const FVector &v);

    virtual void setViewportAngle(const FPoint &angles);

    virtual StarLockLevel getLockLevel() const { return _lockLevel; }

    virtual bool addLockedStar(const FVector v);

    virtual bool removeLockedStar();

    virtual void getRelativeXCenterPixels(double *v1, double *v2, double *v3, double *v4);

    virtual void load(SimpleFile *file, int param);

    virtual void save(SimpleFile *file, int indent);

    float calcAngleForMinDist(FVector &x, FVector &y, float &minDistance);

    bool isMoved() const { return _isMoved; }

    void setIsMoved() { _isMoved = true; }

    void clearIsMoved() { _isMoved = false; }

    bool lockMarker1(FVector v1, FVector v2, FVector v3);

    bool lockMarker2(CViewport *viewport, const FVector &v);

    bool lockMarker3(CViewport *viewport, const FVector &v);
};

} // End of namespace Titanic

#endif /* TITANIC_CAMERA_H */