RoadwayTwist.h

//  trax track library
//  AD 2014 
//
//  "Twist and Shout!"
//
//              The Beatles
//
// Copyright (c) 2025 Trend Redaktions- und Verlagsgesellschaft mbH
// Copyright (c) 2019 Marc-Michael Horstmann
//
// Permission is hereby granted to any person obtaining a copy of this software 
// and associated source code (the "Software"), to use, view, and study the 
// Software for personal or internal business purposes, subject to the following 
// conditions:
//
// 1. Redistribution, modification, sublicensing, or commercial use of the 
// Software is NOT permitted without prior written consent from the copyright 
// holder.
//
// 2. The Software is provided "AS IS", without warranty of any kind, express 
// or implied.
//
// 3. All copies of the Software must retain this license notice.
//
// For further information, please contact: horstmann.marc@trendverlag.de
 
#pragma once

 
#include "Configuration.h"
#include "Units.h"
 
#include "common/Interval.h"
#include "spat/Vector.h"
 
#include <memory>
 
namespace trax
{
    struct TrackBuilder;

    struct RoadwayTwist{
 
        enum class TwistType : char{
            Unknown = -2,
            None = -1,
            Zero = 0,               
            Constant,               
            Linear,                 
            Piecewise,              
            PiecewiseLinear,        
            PiecewiseCircular,      
            PiecewiseDirectional,   
            Directional,            
            Positional,             
            Combined,               
            Parallel
        };
 

        static dclspc std::unique_ptr<RoadwayTwist> Make( TwistType type ) noexcept;

        static dclspc std::unique_ptr<RoadwayTwist> Make( TwistType type, const RoadwayTwist& fromTwist ) noexcept;
 

        virtual const char* TypeName() const noexcept = 0;
 
 
        virtual TwistType GetTwistType() const noexcept = 0;
 

        virtual std::unique_ptr<RoadwayTwist> Clone() const = 0;
 

        virtual bool IsValid() const noexcept = 0;
 

        virtual Angle Twist( Length s ) const = 0;
 

        virtual AnglePerLength D1( Length s ) const = 0;
 

        virtual bool ZeroFlip( bool bActive ) noexcept = 0;
 

        virtual void Flip() noexcept = 0;
 

        virtual void Mirror() noexcept = 0;
 

        virtual bool Offset( Angle offset ) noexcept = 0;
 

        virtual bool IsDynamic() const noexcept = 0;
 

        virtual bool IsDirectionalConstant() const noexcept = 0;
 

        virtual bool IsConstant() const noexcept = 0;
 

        virtual void Freeze( bool bFreeze = true ) noexcept = 0;
 

        virtual bool IsFrozen() const noexcept = 0;
 

        virtual bool IsNull() const noexcept = 0;
 

        virtual bool Equals( const RoadwayTwist& toTwist, Angle epsilon_angle = epsilon__angle ) const noexcept = 0;
 

        virtual void OnAttach( const TrackBuilder& track ) noexcept = 0;
 

        virtual void OnDetach() noexcept = 0;
 

        virtual Angle DoTwist( Length ) const = 0;
 

        virtual AnglePerLength DoD1( Length ) const = 0;
 
 
        virtual ~RoadwayTwist() = default;
        RoadwayTwist( RoadwayTwist&& ) = delete;
        RoadwayTwist& operator=( const RoadwayTwist& ) = delete;
        RoadwayTwist& operator=( RoadwayTwist&& ) = delete;
    protected:
        RoadwayTwist() = default;
        RoadwayTwist( const RoadwayTwist& ) = default;
    };
 

    bool dclspc Equals( 
        const RoadwayTwist& twistA, 
        const RoadwayTwist& twistB, 
        Angle epsilon_angle = epsilon__angle ) noexcept;
 

    dclspc const char* TypeToName( RoadwayTwist::TwistType type );
 

    dclspc RoadwayTwist::TwistType TwistNameToType( const std::string& name ) noexcept;
 

    struct ConstantTwist : RoadwayTwist{

        static dclspc std::unique_ptr<ConstantTwist> Make() noexcept;

        static dclspc std::unique_ptr<ConstantTwist> Make( const RoadwayTwist& fromTwist ) noexcept;
 

        virtual void TwistValue( Angle twist ) noexcept = 0;
 

        virtual Angle TwistValue() const noexcept = 0;
 
        using Data = Angle;
 
        virtual const Data& GetData() const noexcept = 0;
 
        virtual void Create( const Data& data ) noexcept = 0;
    };
 

    struct LinearTwist : RoadwayTwist{

        static dclspc std::unique_ptr<LinearTwist> Make( Angle from = 0_deg, Angle to = 0_deg ) noexcept;
        
        static dclspc std::unique_ptr<LinearTwist> Make( const RoadwayTwist& fromTwist ) noexcept;
 

        using Data = common::Interval<Angle>;
 

        virtual void From( Angle twist ) noexcept = 0;
 

        virtual Angle From() const noexcept = 0;
 

        virtual void To( Angle twist ) noexcept = 0;
 

        virtual Angle To() const noexcept = 0;
 
 
        virtual const Data& GetData() const noexcept = 0;
 
        virtual void Create( const Data& data ) noexcept = 0;
    };
 

    struct PiecewiseTwist : RoadwayTwist
    {
        static dclspc std::unique_ptr<PiecewiseTwist> Make( TwistType type = TwistType::Piecewise ) noexcept;
        
        static dclspc std::unique_ptr<PiecewiseTwist> Make( TwistType type, const RoadwayTwist& fromTwist ) noexcept;
 
        using SegmentValueType = std::pair<Length, Angle>;
        using Data = std::vector<SegmentValueType>;

        virtual void Add( Length s, const Angle& twist ) = 0;
 

        virtual void Add( const std::pair<Length,Angle>& pair ) = 0;
 

        virtual int CntTwistValues() const = 0;
 

        virtual std::pair<Length,Angle> Twist( int idx ) const = 0;
 
        virtual void Create( const Data& data ) = 0;
 
        virtual const Data& GetData() const noexcept = 0;
 
        using RoadwayTwist::Twist;
    };
 

    struct DirectionalTwist : RoadwayTwist{

        static dclspc std::unique_ptr<DirectionalTwist> Make( const spat::Vector<One>& attractor = Up ) noexcept;
        
        static dclspc std::unique_ptr<DirectionalTwist> Make( const RoadwayTwist& fromTwist ) noexcept;
 
        using Data = spat::Vector<One>;

        virtual void Attractor( const spat::Vector<One>& attractor ) = 0;

        virtual const spat::Vector<One>& Attractor() const noexcept = 0;
 

        virtual const spat::Vector<One>& Attractor( bool bGlobal ) const noexcept = 0;
 

        virtual std::shared_ptr<const struct Curve> GetCurve() const noexcept = 0;
 
        virtual const Data& GetData() const noexcept = 0;
 

        virtual void Create( const Data& data ) = 0;
    };
 

    struct PiecewiseDirectionalTwist : RoadwayTwist{

        static dclspc std::unique_ptr<PiecewiseDirectionalTwist> Make() noexcept;
        
        static dclspc std::unique_ptr<PiecewiseDirectionalTwist> Make( const RoadwayTwist& fromTwist ) noexcept;
 
 
        using Data = std::vector<std::pair<Length,spat::Vector<One>>>;
 

        virtual void Add( Length s, const spat::Vector<One>& attractor ) = 0;
 
        virtual void Add( const std::pair<Length,spat::Vector<One>>& pair ) = 0;
 

        virtual int CntTwistValues() const = 0;

        virtual void Create( const Data& data ) = 0;

        virtual std::pair<Length,spat::Vector<One>> Twist( int idx ) const = 0;
 
        virtual const Data& GetData() const noexcept = 0;
 
        using RoadwayTwist::Twist;
    };
 

    struct CombinedTwist : RoadwayTwist{

        static dclspc std::unique_ptr<CombinedTwist> Make() noexcept;

        static dclspc std::unique_ptr<CombinedTwist> Make( const RoadwayTwist& fromTwist ) noexcept;
 

        virtual void AttachTwist1( std::unique_ptr<RoadwayTwist> pTwist ) = 0;
 
        virtual RoadwayTwist& Twist1() const noexcept = 0;
 
        virtual std::unique_ptr<RoadwayTwist> DetachTwist1() = 0;
 

        virtual void AttachTwist2( std::unique_ptr<RoadwayTwist> pTwist ) = 0;
 
        virtual RoadwayTwist& Twist2() const noexcept = 0;
 
        virtual std::unique_ptr<RoadwayTwist> DetachTwist2() = 0;
    };
 

    template<class TwistType>
    const TwistType* FindTwist( const RoadwayTwist& twist ) noexcept{
        if( const auto* pTwist = dynamic_cast<const TwistType*>(&twist) )
            return pTwist;
 
        if( const auto* pCombinedTwist = dynamic_cast<const CombinedTwist*>(&twist) ){
            if( const auto* pTwist2 = FindTwist<const TwistType>(pCombinedTwist->Twist2()) )
                return pTwist2;
            else if( const auto* pTwist1 = FindTwist<const TwistType>(pCombinedTwist->Twist1()) )
                return pTwist1;
        }
 
        return nullptr;
    }
    
    template<class TwistType>
    TwistType* FindTwist( RoadwayTwist& twist ) noexcept{
        if( auto pTwist = dynamic_cast<TwistType*>(&twist) )
            return pTwist;
 
        if( auto pCombinedTwist = dynamic_cast<const CombinedTwist*>(&twist) ){
            if( auto pTwist2 = FindTwist<TwistType>(pCombinedTwist->Twist2()) )
                return pTwist2;
            else if( auto pTwist1 = FindTwist<TwistType>(pCombinedTwist->Twist1()) )
                return pTwist1;
        }
 
        return nullptr;
    }
 
    // for /GR- we export the template instantiations from trax:
    extern template dclspc const ConstantTwist* FindTwist<ConstantTwist>( const RoadwayTwist& twist ) noexcept;
    extern template dclspc const LinearTwist* FindTwist<LinearTwist>( const RoadwayTwist& twist ) noexcept;
    extern template dclspc const PiecewiseTwist* FindTwist<PiecewiseTwist>( const RoadwayTwist& twist ) noexcept;
    extern template dclspc const DirectionalTwist* FindTwist<DirectionalTwist>( const RoadwayTwist& twist ) noexcept;
    extern template dclspc const CombinedTwist* FindTwist<CombinedTwist>( const RoadwayTwist& twist ) noexcept;
 
    extern template dclspc ConstantTwist* FindTwist<ConstantTwist>( RoadwayTwist& twist ) noexcept;
    extern template dclspc LinearTwist* FindTwist<LinearTwist>( RoadwayTwist& twist ) noexcept;
    extern template dclspc PiecewiseTwist* FindTwist<PiecewiseTwist>( RoadwayTwist& twist ) noexcept;
    extern template dclspc DirectionalTwist* FindTwist<DirectionalTwist>( RoadwayTwist& twist ) noexcept;
    extern template dclspc CombinedTwist* FindTwist<CombinedTwist>( RoadwayTwist& twist ) noexcept;
 
 
    //std::unique_ptr<RoadwayTwist> dclspc CreateTwistFrom( RoadwayTwist::TwistType type, const RoadwayTwist& twist );
    //std::unique_ptr<RoadwayTwist> dclspc CreateZeroFrom( const RoadwayTwist& twist );
    //std::unique_ptr<ConstantTwist> dclspc CreateConstantFrom( const RoadwayTwist& twist );
    //std::unique_ptr<LinearTwist> dclspc CreateLinearFrom( const RoadwayTwist& twist );
    //std::unique_ptr<PiecewiseTwist> dclspc CreatePiecewiseFrom( const RoadwayTwist& twist );
    //std::unique_ptr<PiecewiseTwist> dclspc CreatePiecewiseLinearFrom( const RoadwayTwist& twist );
    //std::unique_ptr<PiecewiseTwist> dclspc CreatePiecewiseCircularFrom( const RoadwayTwist& twist );
    //std::unique_ptr<PiecewiseDirectionalTwist> dclspc CreatePiecewiseDirectionalFrom( const RoadwayTwist& twist );
    //std::unique_ptr<DirectionalTwist> dclspc CreateDirectionalFrom( const RoadwayTwist& twist );
}