pscamera.h

Go to the documentation of this file.

/*
 * Author: Andrew Robberts
 *
 * Copyright (C) 2003 Atomic Blue (info@planeshift.it, http://www.atomicblue.org)
 *
 *
 * 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 (version 2 of the License)
 * 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

#ifndef PS_CAMERA_HEADER
#define PS_CAMERA_HEADER
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/csstring.h>
#include <csutil/ref.h>
#include <iutil/virtclk.h>

//=============================================================================
// Project Includes
//=============================================================================
#include "net/cmdbase.h"

//=============================================================================
// Local Includes
//=============================================================================
#include "psoptions.h"

#define NPC_MODE_DISTANCE 5.0f

struct RaceDefinition;
struct iView;
struct iPerspectiveCamera;
struct iSector;
struct iCollideSystem;
struct iMeshWrapper;

class GEMClientActor;
class GEMClientObject;

class psCamera : public iOptionsClass, public psCmdBase
{
public:

    psCamera();
    virtual ~psCamera();

    void LoadOptions();
    void SaveOptions();

    // the different camera modes
    enum CAMERA_MODES
    {
        CAMERA_FIRST_PERSON = 0,
        CAMERA_THIRD_PERSON,
        CAMERA_M64_THIRD_PERSON,
        CAMERA_LARA_THIRD_PERSON,
        CAMERA_FREE,

        // a special hidden camera mode that contains the actual data to use (all other camera modes set this one accordingly)
        CAMERA_ACTUAL_DATA, // this should be the first entry here after the real camera modes
        CAMERA_LAST_ACTUAL, // keep reference to what the actual data was last frame

        // This is a camera mode that occurs in the transition phase in between normal camera modes.
        CAMERA_TRANSITION,

        // camera mode for talking to an NPC
        CAMERA_NPCTALK,

        // A camera mode that is used when a collision occurs.
        // It allows for collisions to be rectified faster than normal
        CAMERA_COLLISION,
        CAMERA_ERR, // this is the error between the actual camera pos and its ideal

        CAMERA_MODES_COUNT
    };

    struct DistanceCfg
    {
        bool adaptive;      // is distance adapted automatically ?
        int dist;           // fixed distance (used when adaptive=false)
        int minFPS;         // acceptable FPS interval (used when adaptive=true)
        int maxFPS;
        int minDist;        // minimum acceptable distance (used when adaptive=true)
    };

    const char *HandleCommand(const char *cmd);
    void HandleMessage(MsgEntry *msg);


    bool InitializeView(GEMClientActor* entity);

    void SetActor(GEMClientActor* entity);

    void npcTargetReplaceIfEqual(GEMClientObject *currentEntity, GEMClientObject* replacementEntity);

    bool LoadFromFile(bool useDefault=false, bool overrideCurrent=true);

    bool SaveToFile();

    bool Draw();

    void SetPosition(const csVector3& pos, int mode = -1);

    csVector3 GetPosition(int mode = -1) const;

    void SetTarget(const csVector3& tar, int mode = -1);

    csVector3 GetTarget(int mode = -1) const;

    void SetUp(const csVector3& up, int mode = -1);

    csVector3 GetUp(int mode = -1) const;

    void LockCameraMode(bool state);

    void SetCameraMode(int mode);

    void NextCameraMode();

    int GetCameraMode() const;

    csString GetCameraModeVerbose() const;

    iPerspectiveCamera *GetICamera();

    iView *GetView();

    iMeshWrapper * Get3DPointFrom2D(int x, int y, csVector3 * worldCoord=0, csVector3 * untransfCoord=0);

    iMeshWrapper* FindMeshUnder2D(int x, int y, csVector3  * pos = NULL, int *poly = NULL);

    void SetPitch(float pitch, int mode = -1);

    void MovePitch(float deltaPitch, int mode = -1);

    float GetPitch(int mode = -1) const;

    void SetPitchVelocity(float pitchVel);

    float GetPitchVelocity() const;

    void SetYaw(float yaw, int mode = -1);

    void MoveYaw(float deltaYaw, int mode = -1);

    float GetYaw(int mode = -1) const;

    void SetYawVelocity(float yawVel);

    float GetYawVelocity() const;

    void SetDistance(float distance, int mode = -1);

    void MoveDistance(float deltaDistance, int mode = -1);

    float GetDistance(int mode = -1) const;

    void ResetActualCameraData();

    void ResetCameraPositioning();

    bool RotateCameraWithPlayer() const;

    csVector3 GetForwardVector(int mode = -1) const;

    csVector3 GetRightVector(int mode = -1) const;

    float GetMinDistance(int mode = -1) const;

    void SetMinDistance(float dist, int mode = -1);

    float GetMaxDistance(int mode = -1) const;

    void SetMaxDistance(float dist, int mode = -1);

    float GetTurnSpeed(int mode = -1) const;

    void SetTurnSpeed(float speed, int mode = -1);

    float GetSpringCoef(int mode = -1) const;

    void SetSpringCoef(float coef, int mode = -1);

    float GetDampeningCoef(int mode = -1) const;

    void SetDampeningCoef(float coef, int mode = -1);

    float GetSpringLength(int mode = -1) const;

    void SetSpringLength(float length, int mode = -1);

    bool CheckCameraCD() const;

    void SetCameraCD(bool useCD);

    bool GetUseNPCCam();

    void SetUseNPCCam(bool useNPCCam);

    float GetTransitionThreshold() const;

    void SetTransitionThreshold(float threshold);

    float GetDefaultPitch(int mode = -1) const;

    void SetDefaultPitch(float pitch, int mode = -1);

    float GetDefaultYaw(int mode = -1) const;

    void SetDefaultYaw(float yaw, int mode = -1);

    float GetSwingCoef(int mode = -1) const;

    void SetSwingCoef(float swingCoef, int mode = -1);

    void UseFixedDistanceClipping(float dist);

    void UseAdaptiveDistanceClipping(int minFPS, int maxFPS, int minDist);

    int GetLastCameraMode();

    DistanceCfg GetDistanceCfg();
    void SetDistanceCfg(DistanceCfg newcfg);

    int GetFixedDistClip() { return fixedDistClip; }

    bool IsInitialized() { return cameraInitialized; }

private:

    struct CameraData
    {
        csVector3 worldPos;
        csVector3 worldTar;
        csVector3 worldUp;

        float pitch;
        float yaw;
        float roll; // not implemented yet (no need atm)

        float defaultPitch;
        float defaultYaw;
        float defaultRoll;

        float distance; // the distance between position and target
        float minDistance;
        float maxDistance;

        float turnSpeed;

        float springCoef;
        float InertialDampeningCoef;
        float springLength;

        float swingCoef;

        //initialize all here:
        CameraData()
        {
            worldPos.Set(0.0f,0.0f,0.0f);
            worldTar.Set(0.0f,0.0f,0.0f);
            worldUp.Set(0.0f,0.0f,0.0f);
            pitch = yaw = roll = 0;
            defaultPitch = defaultYaw = defaultRoll = 0.0f;
            distance = minDistance = maxDistance = 0.0f;
            turnSpeed  = 0.0f;
            springCoef = InertialDampeningCoef = springLength = 0.0f;
            swingCoef=0.0f;
        }
    };

    float CalcSpringCoef(float springyness, float scale) const;
    float CalcInertialDampeningCoef(float springyness, float scale) const;
    float EstimateSpringyness(size_t camMode) const;

    void DoCameraIdealCalcs(const csTicks elapsedTicks, const csVector3& actorPos, const csVector3& actorEye, const float actorYRot);

    csVector3 CalcCollisionPos(const csVector3& pseudoTarget, const csVector3& pseudoPosition, iSector*& sector);

    void DoCameraTransition();

    void DoElasticPhysics(bool isElastic, const csTicks elapsedTicks, const CameraData& deltaIdeal, iSector* sector);

    void EnsureActorVisibility();

    csVector3 CalcElasticPos(csVector3 currPos, csVector3 idealPos, csVector3 deltaIdealPos,
                             float deltaTime, float springCoef, float dampCoef, float springLength) const;


    float CalcElasticFloat(float curr, float ideal, float deltaIdeal,
                           float deltaTime, float springCoef, float dampCoef, float springLength) const;


    void CalculateFromYawPitchRoll(int mode = -1);

    void CalculateNewYawPitchRoll(int mode = -1);

    void CalculatePositionFromYawPitchRoll(int mode = -1);

    float CalculateNewYaw(csVector3 dir);

    void EnsureCameraDistance(int mode = -1);

    bool IsActorVisible(int mode = -1) const;

    float SaturateAngle(float angle) const;

    bool CloneCameraModeData(int fromMode, int toMode = -1);

    void SetDistanceClipping(float dist);
    float GetDistanceClipping();

    void AdaptDistanceClipping();

    // each mode's camera data has to be handled seperately
    CameraData camData[CAMERA_MODES_COUNT];

    int lastCameraMode;
    int currCameraMode;

    // velocity stuff
    float pitchVelocity;
    float yawVelocity;

    // some camera settings
    // NOTE: the offsets are not in the format you think they are, due to speed issues the offset is restricted to being directly behind the actor (no yaw).
    csVector3 firstPersonPositionOffset;
    csVector3 thirdPersonPositionOffset;

    /* if the squared difference between the actual camera position and the ideal position is less than this,
     * then we're no longer in the transition phase.
     */
    float transitionThresholdSquared;
    bool inTransitionPhase;

    bool hasCollision;

    bool cameraHasBeenPositioned;

    bool useCameraCD;

    bool useNPCCam;

    bool cameraInitialized;

    bool lockedCameraMode;

    csWeakRef<iSector> lastTargetSector;

    GEMClientActor* actor;

    csRef<iView> view;

    csRef<iVirtualClock> vc;

    csRef<iCollideSystem> cdsys;

    csTicks prevTicks;

    RaceDefinition *race;

    DistanceCfg distanceCfg;

    GEMClientActor* npcModeTarget;

    csVector3 npcModePosition;

    float npcOldRot;
    float vel;
    int fixedDistClip;
};

#endif