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