SlideNode.h

Go to the documentation of this file.

/*
    This source file is part of Rigs of Rods
    Copyright 2005-2012 Pierre-Michel Ricordel
    Copyright 2007-2012 Thomas Fischer
    Copyright 2009 Christopher Ritchey
    Copyright 2018 Petr Ohlidal
 
    For more information, see http://www.rigsofrods.org/
 
    Rigs of Rods is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 3, as
    published by the Free Software Foundation.
 
    Rigs of Rods 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 Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
*/
 
 
#pragma once
 
#include "ForwardDeclarations.h"
 
#include <OgreVector3.h>
#include <vector>
 
namespace RoR {
 
 
struct RailSegment
{
    RailSegment(beam_t* beam): rs_prev(nullptr), rs_next(nullptr), rs_beam(beam) {}
 
    RailSegment* CheckCurSlideSegment(Ogre::Vector3 const& point );
 
    RailSegment*   rs_prev;
    RailSegment*   rs_next;
    beam_t*        rs_beam;
};
struct RailSegment {…};
 
struct RailGroup
{
    RailGroup(): rg_id(-1) {}
 
    RailSegment* FindClosestSegment(Ogre::Vector3 const& point );
 
    std::vector<RailSegment> rg_segments;
    int                      rg_id; 
};
struct RailGroup {…};
 
class SlideNode
{
public:
    SlideNode(node_t* sliding_node, RailGroup* rail);
 
    int GetSlideNodeId();
 
    void UpdateForces(float dt);
 
    void UpdatePosition();
 
    void SetDefaultRail(RailGroup* rail)
    {
        m_initial_railgroup = m_cur_railgroup = rail;
        this->ResetPositions();
    }
    void SetDefaultRail(RailGroup* rail) {…}
 
    void ResetPositions();
 
    void ResetSlideNode()
    {
        m_cur_railgroup = m_initial_railgroup;
        sn_slide_broken = false;
        this->ResetPositions();
    }
    void ResetSlideNode() {…}
 
    void           SetCorThreshold(float threshold )   { m_initial_threshold = m_cur_threshold = fabs( threshold ); } 
    void           SetSpringRate(float rate )          { m_spring_rate = fabs( rate); }      
    void           SetBreakForce(float breakRate )     { m_break_force = fabs( breakRate); } 
    void           SetAttachmentRate(float rate )      { m_attach_rate = fabs( rate); }      
    void           SetAttachmentDistance(float dist )  { m_attach_distance = fabs( dist); }  
    float          GetAttachmentDistance() const       { return m_attach_distance; }         
 
    bool sn_attach_self:1;      
    bool sn_attach_foreign:1;   
    bool sn_slide_broken:1;     
 
private:
    Ogre::Vector3 CalcCorrectiveForces();
 
    node_t*        m_sliding_node;        
    beam_t*        m_sliding_beam;        
    RailGroup*     m_initial_railgroup;   
    RailGroup*     m_cur_railgroup;       
    RailSegment*   m_cur_rail_seg;        
    float          m_node_forces_ratio;   
    Ogre::Vector3  m_ideal_position;      
    float          m_initial_threshold;   
    float          m_cur_threshold;       
    float          m_spring_rate;         
    float          m_break_force;         
    float          m_attach_rate;         
    float          m_attach_distance;     
 
// Methods //////////////////////////// TO BE SORTED /////////////////////////////////////////
public:
 
    const Ogre::Vector3& GetSlideNodePosition() const;
 
    void AttachToRail(RailGroup* toAttach)
    {
        m_cur_railgroup = toAttach;
        this->ResetPositions();
        m_cur_threshold = (m_sliding_beam ? getLenTo(m_sliding_beam) : m_initial_threshold);
    }
    void AttachToRail(RailGroup* toAttach) {…}
 
    static Ogre::Real getLenTo( const RailGroup* group, const Ogre::Vector3& point );
 
    static Ogre::Real getLenTo( const RailSegment* rail, const Ogre::Vector3& point );
 
    static Ogre::Real getLenTo( const beam_t* beam, const Ogre::Vector3& point );
 
 
    Ogre::Real getLenTo( const RailGroup* group ) const;
 
    Ogre::Real getLenTo( const RailSegment* rail ) const;
 
    Ogre::Real getLenTo( const beam_t* beam) const;
};
 
 
} // namespace RoR
 
    bool sn_attach_self:1;       {…};
    float          GetAttachmentDistance() const       { return m_attach_distance; }          {…}
    void           SetAttachmentDistance(float dist )  { m_attach_distance = fabs( dist); }   {…}
    void           SetAttachmentRate(float rate )      { m_attach_rate = fabs( rate); }       {…}
    void           SetBreakForce(float breakRate )     { m_break_force = fabs( breakRate); }  {…}
    void           SetSpringRate(float rate )          { m_spring_rate = fabs( rate); }       {…}
class SlideNode {…};