Camera.h

//  Copyright (c) 2021 Marc-Michael Horstmann. All Rights Reserved.
//
//  trax track library
//  AD 2016
//
//  "the resolution of all the fruitless searches"
//
//                              Peter Gabriel
 
#pragma once
 
#include "trax/Configuration.h"
#include "CameraType.h"
#include "trax/Identified.h"
#include "trax/Units.h"
#include "trax/collections/Collection.h"
 
#include "spat/Frame.h"
//#include "TriggerShape.h"
 
namespace common{
    template<typename> struct Interval;
}
 
namespace spat{
    template<typename> class Transformation;
}
 
namespace trax{
 
    struct Body;
    struct GeomList;
    struct Module;
 
    class Location;

    struct Frustum{
        static const Angle default_fovy;
        static const One default_aspect;
        static const Length default_nearPlane;
        static const Length default_farPlane;
 
        virtual void SetFromFofy( Angle fovy = default_fovy, One aspect = default_aspect, Length zn = default_nearPlane, Length zf = default_farPlane ) = 0;
 
        virtual void SetFromDimensions( Length width, Length height, Length zn = default_nearPlane, Length zf = default_farPlane ) = 0;
 
        virtual void PlaneDistances( const common::Interval<Length>& planes ) = 0;
 
        virtual Length NearPlaneDistance() const = 0;
 
        virtual Length FarPlaneDistance() const = 0;
 
        virtual void Width( Length width ) = 0;
 
        virtual Length Width() const = 0;
 
        virtual void Height( Length height ) = 0;
 
        virtual Length Height() const = 0;

        virtual void Fovy( Angle fovy ) = 0;

        virtual Angle Fovy() const = 0;

        virtual void AspectRatio( One aspect ) = 0;

        virtual One AspectRatio() const = 0;
 
        virtual void ProjectionMatrix( const spat::Transformation<Real>& projection ) = 0;
 
        virtual const spat::Transformation<Real>& ProjectionMatrix() const = 0;
 
        virtual spat::Transformation<Real>& ProjectionMatrix() = 0;
 
        virtual ~Frustum() = default;
        Frustum( const Frustum& ) = delete;
        Frustum( Frustum&& ) = delete;
        Frustum& operator=( const Frustum& ) = delete;
        Frustum& operator=( Frustum&& ) = delete;
    protected:
        Frustum() = default;
    };

    struct Camera : Frustum,
                    Identified<Camera>
    {
        static dclspc std::unique_ptr<Camera> Make( CameraType type = CameraType::cam_basic ) noexcept;
 

        virtual const char* TypeName() const noexcept = 0;
 
 
        virtual Camera& operator=( const Camera& camera ) = 0;
 

        virtual CameraType GetType() const = 0;
 
 
        // Object's pose:

        virtual void SetFrame( const spat::Frame<Length,One>& frame ) = 0;
 

        virtual const spat::Frame<Length,One>& GetFrame() const = 0;
 
        virtual spat::Frame<Length,One>& GetFrame() = 0;
 

        virtual spat::Vector<Velocity> GetVelocity() const = 0;

        virtual void EyePoint( const spat::Position<Length>& eyePoint ) = 0;
 
        virtual spat::Position<Length> EyePoint() const = 0;
 
        virtual void Up( const spat::Vector<One>& up ) = 0;
 
        virtual spat::Vector<One> Up() const = 0;
 
        virtual void LookAt( const spat::Position<Length>& lookAtPoint ) = 0;
 
        virtual spat::Position<Length> LookAt() const = 0;
 

        virtual bool InFrustum( const spat::Position<Length>& position ) const = 0;
    };

    struct AnimatedCamera : virtual Camera{
 
        using Camera::operator=;

        virtual void AttachTo( std::shared_ptr<Module> pModule ) = 0;
 

        virtual std::shared_ptr<Module> GetModule() const = 0;
 
 
        virtual std::vector<GeomList*> OverlapQuery( unsigned int filterflags ) const = 0;
 
        virtual GeomList* OverlapQueryAny( unsigned int filterflags ) const = 0;
 

        virtual void Update() = 0;
 

        virtual void StepBack() = 0;
 

        virtual void Stop() = 0;
 

        virtual void Reset() = 0;
 

        virtual void MaximumLinearVelocity( Velocity maxVelocity ) = 0;
 
        virtual Velocity MaximumLinearVelocity() const = 0;
 

        virtual void SetVelocity( const spat::Vector<Velocity>& velocity ) = 0;
 
        virtual void SetVelocity( const spat::Vector<Velocity>& linearVelocity, const spat::Vector<AngularVelocity>& rotationalVelocity ) = 0;

        virtual void RotationalVelocity( const spat::Vector<AngularVelocity>& rotvel ) = 0;


        virtual void ControllerTranslateX( Velocity dx ) = 0;
 
        virtual void ControllerTranslateY( Velocity dy ) = 0;
 
        virtual void ControllerTranslateZ( Velocity dz ) = 0;
 
        virtual void ControllerRotateX( AngularVelocity dx ) = 0;
 
        virtual void ControllerRotateY( AngularVelocity dy ) = 0;
 
        virtual void ControllerRotateZ( AngularVelocity dz ) = 0;


        virtual void DampingTranslate( Real damping ) = 0;
 
        virtual Real DampingTranslate() const = 0;
 
        virtual void DampingRotate( Real damping ) = 0;
 
        virtual Real DampingRotate() const = 0;
    };

    struct BodyCam : virtual AnimatedCamera{
 
        using Camera::operator=;
 
        using AnimatedCamera::AttachTo;

        virtual void AttachTo( std::shared_ptr<Body> pBody ) = 0;
 

        virtual std::shared_ptr<Body> GetBody() const = 0;
 


        virtual void Center( const spat::Frame<Length,One>& center ) = 0;
 
        virtual const spat::Frame<Length,One>& Center() const = 0;
 

        virtual bool GetLoose() const = 0;
 

        virtual bool BodyRealtiveRotations() const = 0;
 
        virtual void PhiLimits( const common::Interval<Angle>& limits ) = 0;
 
        virtual const common::Interval<Angle>& PhiLimits() const = 0;
 
        virtual void PhiResetValue( Angle phi ) = 0;
 
        virtual Angle PhiResetValue() const = 0;
 
        virtual void Phi( Angle phi ) = 0;
 
        virtual Angle Phi() const = 0;
 
 
        virtual void ThetaLimits( const common::Interval<Angle>& limits ) = 0;
 
        virtual const common::Interval<Angle>& ThetaLimits() const = 0;
 
        virtual void ThetaResetValue( Angle theta ) = 0;
 
        virtual Angle ThetaResetValue() const = 0;
 
        virtual void Theta( Angle theta ) = 0;
 
        virtual Angle Theta() const = 0;
 
 
        virtual void RadiusLimits( const common::Interval<Length>& limits ) = 0;
 
        virtual const common::Interval<Length>& RadiusLimits() const = 0;
 
        virtual void RadiusResetValue( Length radius ) = 0;
 
        virtual Length RadiusResetValue() const = 0;
 
        virtual void Radius( Length radius ) = 0;
 
        virtual Length Radius() const = 0;
    };
 

    struct DollyCam : Camera{
 
        using Camera::operator=;
 
        virtual const Location& GetLocation() const = 0;
    };

    struct CameraCollection :   Collection<CameraCollection,Camera>/*,
                                virtual TriggerShapeCollection*/
    {
        static dclspc std::unique_ptr<CameraCollection> Make() noexcept;
 
 
        virtual void UserCameraType( CameraType type ) = 0;
 
        virtual CameraType UserCameraType() const = 0;
 
        virtual void UserStartCameraID( IDType id ) = 0;
 
        virtual IDType UserStartCameraID() const = 0;
 
        //virtual void Update( const Simulator& simulator ) = 0;
 
        //using TriggerShapeCollection::Update;
    };
 
    struct Fleet;
    struct Train;
 

    //dclspc std::vector<std::shared_ptr<Train>> GetVisibleTrains( const Fleet& fleet, const Camera& camera );
}