Section.h

//  trax track library
//  AD 2013 
//
//  "the resolution of all the fruitless searches"
//
//                              Peter Gabriel
//
// 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/Rect.h"
#include "spat/Position2D.h"
#include "spat/Vector2D.h"
 
#include "Units.h"
 
namespace trax{

    struct Section{

        virtual std::string TypeName() const noexcept = 0;
 

        enum class SpecialSections{
            unknown = -1,
            empty = 0,                  
            custom,                     
            standard,                   
            vignol_UIC60,               
            eepv7_grooved_convextread,  
            eep_embankment_simple,      
            eep_concrete_roadway,       
            eep_rack_railway,           
            eep7_track1435,             
            eep_simple,                 
            eep_grooved_convextread,    
            eep_flatballast,            
            eepv7_track1000,            
            eep_simple2,                
            eep_simple3,                
            eep_flatballast_rods,       
            square,                     
            hexagon,                    
            pipeline,                   
        };

        static dclspc std::unique_ptr<Section> Make( SpecialSections special = SpecialSections::empty ) noexcept;
 
        virtual SpecialSections GetSectionType() const noexcept = 0;
 

        struct SectionPoint{
            spat::Position2D<Length>    p;  
            spat::Vector2D<One>         n;  
            One                         t;  
 

            SectionPoint() noexcept
            :   p{},
                n{},
                t{}
            {}
 
            SectionPoint( const spat::Position2D<Length>& pt ) noexcept
            :   p{pt},
                n{0,1},
                t{0}
            {}
 
            SectionPoint( const spat::Position2D<Length>& pt, const spat::Vector2D<One>& d, One tex ) noexcept
            :   p{pt},
                n{d},
                t{tex}
            {}
 

            SectionPoint& Scale( One scale ) noexcept{
                return Scale( scale, scale );
            }
 
            SectionPoint& Scale( One x_scale, One y_scale ) noexcept{
                p.x *= x_scale;
                p.y *= y_scale;
                n.dx /= x_scale;
                n.dy /= y_scale;
                n.Normalize();
                return *this;
            }
 
        };
 

        virtual void Create( SpecialSections specialSection ) = 0;
 

        virtual int CountPoints() const = 0;
 

        virtual void SetCntPoints( int cnt ) = 0;
 

        virtual const SectionPoint& Get( int id ) const = 0;
 

        virtual common::Interval<One> TextureExtent() const = 0;
 

        virtual Length PolygonChainLength() const noexcept = 0;
 

        virtual Length Gauge() const noexcept = 0;
 

        virtual spat::Rect<Length> Clearance() const noexcept = 0;
 

        virtual void Set( int id, const SectionPoint& pt, bool bGaugeLeft = false, bool bGaugeRight = false ) = 0;
 

        virtual void Scale( One x_scale, One y_scale ) = 0;
 

        virtual void CalculateNormals() noexcept = 0;

        virtual void CalculateTextureCoordinates() = 0;
 
 
        virtual ~Section() = default;
        Section( const Section& ) = delete;
        Section( Section&& ) = delete;
        Section& operator=( const Section& ) = delete;
        Section& operator=( Section&& ) = delete;
    protected:
        Section() = default;
    };
 
    dclspc std::string ToString( Section::SpecialSections specialSection );
 
    dclspc Section::SpecialSections SpecialSection( const std::string& string );
}