SimData.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 2013-2023 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 "Application.h"
#include "ForwardDeclarations.h"
#include "SimConstants.h"
#include "BitFlags.h"
#include "CmdKeyInertia.h"
#include "InputEngine.h"
 
#include <memory>
#include <Ogre.h>
#include <rapidjson/document.h>
 
namespace RoR {
 
enum CollisionEventFilter: short
{
    EVENT_NONE = 0,          
    EVENT_ALL,               
    EVENT_AVATAR,            
    EVENT_TRUCK,             
    EVENT_TRUCK_WHEELS,      
    EVENT_AIRPLANE,          
    EVENT_BOAT,              
};
enum CollisionEventFilter: short {…};
 
 
 
enum BeamType: short
{
    BEAM_NORMAL,
    BEAM_HYDRO,
    BEAM_VIRTUAL,         
};
enum BeamType: short {…};
 
 
 
enum HookState
{
    UNLOCKED,       
    PRELOCK,        
    LOCKED          
};
enum HookState {…};
 
enum ActorType 
{
    // DO NOT MODIFY NUMBERS - serialized into cache file, see RoR::CacheEntry
 
    NOT_DRIVEABLE  = 0,   
    TRUCK          = 1,   
    AIRPLANE       = 2,   
    BOAT           = 3,   
    MACHINE        = 4,   
    AI             = 5,   
};
enum ActorType  {…};
 
 
 
enum SpecialBeam: short 
{
    NOSHOCK,        
    SHOCK1,         
    SHOCK2,         
    SHOCK3,         
    TRIGGER,        
    SUPPORTBEAM,    
    ROPE            
};
enum SpecialBeam: short  {…};
 
 
 
enum BlinkType 
{
    BLINK_NONE,     
    BLINK_LEFT,     
    BLINK_RIGHT,    
    BLINK_WARN      
};
enum BlinkType  {…};
 
enum HydroFlags
{
    HYDRO_FLAG_SPEED        = BITMASK(1),
    HYDRO_FLAG_DIR          = BITMASK(2),
    HYDRO_FLAG_AILERON      = BITMASK(3),
    HYDRO_FLAG_RUDDER       = BITMASK(4),
    HYDRO_FLAG_ELEVATOR     = BITMASK(5),
    HYDRO_FLAG_REV_AILERON  = BITMASK(6),
    HYDRO_FLAG_REV_RUDDER   = BITMASK(7),
    HYDRO_FLAG_REV_ELEVATOR = BITMASK(8),
};
enum HydroFlags {…};
 
enum AnimFlags
{
    ANIM_FLAG_AIRSPEED      = BITMASK(1),
    ANIM_FLAG_VVI           = BITMASK(2),
    ANIM_FLAG_ALTIMETER     = BITMASK(3),
    ANIM_FLAG_AOA           = BITMASK(4),
    ANIM_FLAG_FLAP          = BITMASK(5),
    ANIM_FLAG_AIRBRAKE      = BITMASK(6),
    ANIM_FLAG_ROLL          = BITMASK(7),
    ANIM_FLAG_PITCH         = BITMASK(8),
    ANIM_FLAG_THROTTLE      = BITMASK(9),
    ANIM_FLAG_RPM           = BITMASK(10),
    ANIM_FLAG_ACCEL         = BITMASK(11),
    ANIM_FLAG_BRAKE         = BITMASK(12),
    ANIM_FLAG_CLUTCH        = BITMASK(13),
    ANIM_FLAG_TACHO         = BITMASK(14),
    ANIM_FLAG_SPEEDO        = BITMASK(15),
    ANIM_FLAG_PBRAKE        = BITMASK(16),
    ANIM_FLAG_TURBO         = BITMASK(17),
    ANIM_FLAG_SHIFTER       = BITMASK(18),
    ANIM_FLAG_AETORQUE      = BITMASK(19),
    ANIM_FLAG_AEPITCH       = BITMASK(20),
    ANIM_FLAG_AESTATUS      = BITMASK(21),
    ANIM_FLAG_TORQUE        = BITMASK(22),
    ANIM_FLAG_HEADING       = BITMASK(23),
    ANIM_FLAG_DIFFLOCK      = BITMASK(24),
    ANIM_FLAG_STEERING      = BITMASK(25),
    ANIM_FLAG_EVENT         = BITMASK(26),
    ANIM_FLAG_AILERONS      = BITMASK(27),
    ANIM_FLAG_ARUDDER       = BITMASK(28),
    ANIM_FLAG_BRUDDER       = BITMASK(29),
    ANIM_FLAG_BTHROTTLE     = BITMASK(30),
    ANIM_FLAG_PERMANENT     = BITMASK(31),
    ANIM_FLAG_ELEVATORS     = BITMASK(32),
};
enum AnimFlags {…};
 
enum AnimModes
{
    ANIM_MODE_ROTA_X        = BITMASK(1),
    ANIM_MODE_ROTA_Y        = BITMASK(2),
    ANIM_MODE_ROTA_Z        = BITMASK(3),
    ANIM_MODE_OFFSET_X      = BITMASK(4),
    ANIM_MODE_OFFSET_Y      = BITMASK(5),
    ANIM_MODE_OFFSET_Z      = BITMASK(6),
    ANIM_MODE_AUTOANIMATE   = BITMASK(7),
    ANIM_MODE_NOFLIP        = BITMASK(8),
    ANIM_MODE_BOUNCE        = BITMASK(9),
};
enum AnimModes {…};
 
 
 
enum ShockFlags
{
    SHOCK_FLAG_NORMAL           = BITMASK(1),
    SHOCK_FLAG_LACTIVE          = BITMASK(3),
    SHOCK_FLAG_RACTIVE          = BITMASK(4),
    SHOCK_FLAG_ISSHOCK2         = BITMASK(5),
    SHOCK_FLAG_ISSHOCK3         = BITMASK(6),
    SHOCK_FLAG_SOFTBUMP         = BITMASK(7),
    SHOCK_FLAG_ISTRIGGER        = BITMASK(8),
    SHOCK_FLAG_TRG_BLOCKER      = BITMASK(9),
    SHOCK_FLAG_TRG_CMD_SWITCH   = BITMASK(10),
    SHOCK_FLAG_TRG_CMD_BLOCKER  = BITMASK(11),
    SHOCK_FLAG_TRG_BLOCKER_A    = BITMASK(12),
    SHOCK_FLAG_TRG_HOOK_UNLOCK  = BITMASK(13),
    SHOCK_FLAG_TRG_HOOK_LOCK    = BITMASK(14),
    SHOCK_FLAG_TRG_CONTINUOUS   = BITMASK(15),
    SHOCK_FLAG_TRG_ENGINE       = BITMASK(16)
};
enum ShockFlags {…};
 
 
 
enum EngineTriggerType
{
    TRG_ENGINE_CLUTCH    = 0,
    TRG_ENGINE_BRAKE     = 1,
    TRG_ENGINE_ACC       = 2,
    TRG_ENGINE_RPM       = 3,
    TRG_ENGINE_SHIFTUP   = 4,
    TRG_ENGINE_SHIFTDOWN = 5 
};
enum EngineTriggerType {…};
 
 
enum LocalizerType
{
    LOCALIZER_VERTICAL,
    LOCALIZER_HORIZONTAL,
    LOCALIZER_NDB,
    LOCALIZER_VOR
};
enum LocalizerType {…};
 
 
 
enum class ActorState
{
    LOCAL_SIMULATED,  
    NETWORKED_OK,     
    NETWORKED_HIDDEN, 
    LOCAL_REPLAY,
    LOCAL_SLEEPING,   
    DISPOSED          
};
enum class ActorState {…};
 
enum class AeroEngineType : int
{
    AE_UNKNOWN,
    AE_XPROP,
    AE_TURBOJET,
};
enum class AeroEngineType : int {…};
 
// --------------------------------
// Soft body physics
 
struct node_t
{
    static const int8_t    INVALID_BBOX = -1;
 
    node_t()               { memset(this, 0, sizeof(node_t)); nd_coll_bbox_id = INVALID_BBOX; }
    node_t(size_t _pos)    { memset(this, 0, sizeof(node_t)); nd_coll_bbox_id = INVALID_BBOX; pos = static_cast<short>(_pos); }
 
    Ogre::Vector3   RelPosition;             
    Ogre::Vector3   AbsPosition;             
    Ogre::Vector3   Velocity;
    Ogre::Vector3   Forces;
 
    Ogre::Real      mass;
    Ogre::Real      buoyancy;
    Ogre::Real      friction_coef;
    Ogre::Real      surface_coef;
    Ogre::Real      volume_coef;
 
    NodeNum_t       pos;                     
    int16_t         nd_coll_bbox_id;         
    int16_t         nd_lockgroup;            
 
    // Bit flags
    bool            nd_cab_node:1;           
    bool            nd_rim_node:1;           
    bool            nd_tyre_node:1;          
    bool            nd_contacter:1;          
    bool            nd_contactable:1;        
    bool            nd_has_ground_contact:1; 
    bool            nd_has_mesh_contact:1;   
    bool            nd_immovable:1;          
    bool            nd_loaded_mass:1;        
    bool            nd_no_ground_contact:1;  
    bool            nd_override_mass:1;      
    bool            nd_under_water:1;        
    bool            nd_no_mouse_grab:1;      
    bool            nd_cinecam_node:1;       
 
    Ogre::Real      nd_avg_collision_slip;   
    Ogre::Vector3   nd_last_collision_slip;  
    Ogre::Vector3   nd_last_collision_force; 
    ground_model_t* nd_last_collision_gm;    
};
struct node_t {…};
 
struct beam_t
{
    beam_t();
    ~beam_t();
 
    node_t*         p1 = nullptr;
    node_t*         p2 = nullptr;
    float           k = 0.f;                     
    float           d = 0.f;                     
    float           L = 0.f;                     
    float           minmaxposnegstress = 0.f;
    float           maxposstress = 0.f;
    float           maxnegstress = 0.f;
    float           strength = 0.f;
    float           stress = 0.f;
    float           plastic_coef = 0.f;
    int             detacher_group = DEFAULT_DETACHER_GROUP; 
    SpecialBeam     bounded = SpecialBeam::NOSHOCK;
    BeamType        bm_type = BeamType::BEAM_NORMAL;
    bool            bm_inter_actor = false;      
    ActorPtr        bm_locked_actor;             
    bool            bm_disabled = false;
    bool            bm_broken = false;
 
    float           shortbound = 0.f;
    float           longbound = 0.f;
    float           refL = 0.f;                  
 
    shock_t*        shock = nullptr;
 
    float           initial_beam_strength = 0.f; 
    float           default_beam_deform = 0.f;   
    float           default_beam_diameter = 0.f; 
 
    float           debug_k = 0.f;               
    float           debug_d = 0.f;               
    float           debug_v = 0.f;               
};
struct beam_t {…};
 
struct shock_t
{
    shock_t() { memset(this, 0, sizeof(shock_t)); }
 
    int beamid;
    int flags;
 
    bool trigger_enabled;       
    float trigger_switch_state; 
    float trigger_boundary_t;   
    int trigger_cmdlong;        
    int trigger_cmdshort;       
    int last_debug_state;       
 
    float springin;  
    float dampin;    
    float springout; 
    float dampout;   
 
    float sprogin;   
    float dprogin;   
    float sprogout;  
    float dprogout;  
 
    float splitin;   
    float dslowin;   
    float dfastin;   
    float splitout;  
    float dslowout;  
    float dfastout;  
 
    float sbd_spring;           
    float sbd_damp;             
    float sbd_break;            
 
    float shock_precompression; 
};
struct shock_t {…};
 
struct collcab_rate_t
{
    int rate;     // remaining amount of physics cycles to be skipped
    int distance; // distance (in physics cycles) to the previous collision check
};
struct collcab_rate_t {…};
 
 
struct soundsource_t
{
    soundsource_t();
    ~soundsource_t();
 
    SoundScriptInstancePtr ssi;
    NodeNum_t nodenum;
    int type;
};
struct soundsource_t {…};
 
struct wheel_t
{
    int         wh_num_nodes;
    node_t*     wh_nodes[50];             // TODO: remove limit, make this dyn-allocated ~ only_a_ptr, 08/2017
    int         wh_num_rim_nodes;
    node_t*     wh_rim_nodes[50];         // TODO: remove limit, make this dyn-allocated ~ only_a_ptr, 08/2017
    WheelBraking wh_braking;
    node_t*     wh_arm_node;
    node_t*     wh_near_attach_node;
    node_t*     wh_axis_node_0;
    node_t*     wh_axis_node_1;
    WheelPropulsion wh_propulsed;
    Ogre::Real  wh_radius;
    Ogre::Real  wh_rim_radius;
    Ogre::Real  wh_speed;             
    Ogre::Real  wh_avg_speed;         
    Ogre::Real  wh_alb_coef;          
    Ogre::Real  wh_tc_coef;           
    Ogre::Real  wh_mass;              
    Ogre::Real  wh_torque;            
    Ogre::Real  wh_last_torque;       
    Ogre::Real  wh_last_retorque;     
    float       wh_net_rp;
    float       wh_width;
    bool        wh_is_detached;
 
    // Editing & Export (not used in simulation)
    RigDef::Keyword wh_arg_keyword;
    int             wh_arg_num_rays;
    NodeNum_t       wh_arg_rigidity_node;
    float           wh_arg_rim_spring;      
    float           wh_arg_rim_damping;     
    float           wh_arg_simple_spring;   
    float           wh_arg_simple_damping;  
    WheelSide       wh_arg_side;            
    std::string     wh_arg_media1;
    std::string     wh_arg_media2;
    int             wh_beam_start;          
 
    // Debug
    float debug_rpm;
    float debug_torque;
    Ogre::Vector3 debug_vel;
    Ogre::Vector3 debug_slip;
    Ogre::Vector3 debug_force;
    Ogre::Vector3 debug_scaled_cforce;
};
struct wheel_t {…};
 
struct wheeldetacher_t
{
    int wd_wheel_id;
    int wd_detacher_group;
};
struct wheeldetacher_t {…};
 
 
struct hook_t
{
    hook_t();
    ~hook_t();
 
    HookState  hk_locked = HookState::UNLOCKED;
    int        hk_group = 0;
    int        hk_lockgroup = 0;
    bool       hk_selflock = false;
    bool       hk_autolock = false;
    bool       hk_nodisable = false;
    float      hk_maxforce = 0.f;
    float      hk_lockrange = 0.f;
    float      hk_lockspeed = 0.f;
    float      hk_timer = 0.f;
    float      hk_timer_preset = 0.f;
    float      hk_min_length = 0.f; 
    node_t*    hk_hook_node = nullptr;
    node_t*    hk_lock_node = nullptr;
    beam_t*    hk_beam = nullptr;
    ActorPtr   hk_locked_actor;
};
struct hook_t {…};
 
struct ropable_t
{
    node_t *node;
    int pos;            
    int group;
    int attached_ties;  
    int attached_ropes; 
    bool multilock;     
};
struct ropable_t {…};
 
struct rope_t
{
    rope_t();
    ~rope_t();
 
    int        rp_locked = 0;
    int        rp_group = 0;
    beam_t*    rp_beam = nullptr;
    ropable_t* rp_locked_ropable = nullptr;
    ActorPtr   rp_locked_actor;
};
struct rope_t {…};
 
struct tie_t
{
    tie_t();
    ~tie_t();
 
    ActorPtr   ti_locked_actor;
    beam_t*    ti_beam = nullptr;
    ropable_t* ti_locked_ropable = nullptr;
    int        ti_group = 0;
    float      ti_contract_speed = 0.f;
    float      ti_max_stress = 0.f;
    float      ti_min_length = 0.f;       
 
    bool       ti_no_self_lock:1;   
    bool       ti_tied:1;           
    bool       ti_tying:1;          
};
struct tie_t {…};
 
struct wing_t
{
    FlexAirfoil *fa;
    Ogre::SceneNode *cnode;
};
struct wing_t {…};
 
struct commandbeam_state_t
{
    commandbeam_state_t() { memset(this, 0, sizeof(commandbeam_state_t)); }
 
    int8_t   auto_moving_mode;      
 
    // Bit flags
    bool     pressed_center_mode:1; 
    bool     auto_move_lock:1;      
};
struct commandbeam_state_t {…};
 
struct commandbeam_t
{
    uint16_t cmb_beam_index;            
    float    cmb_engine_coupling;       
    float    cmb_center_length;         
    float    cmb_speed;                 
    float    cmb_boundary_length;       
 
    // Bit flags
    bool     cmb_is_contraction:1;      
    bool     cmb_is_force_restricted:1; 
    bool     cmb_needs_engine:1;        
    bool     cmb_is_autocentering:1;    
    bool     cmb_plays_sound:1;         
    bool     cmb_is_1press:1;           
    bool     cmb_is_1press_center:1;    
 
    std::shared_ptr<commandbeam_state_t> cmb_state;
};
struct commandbeam_t {…};
 
struct command_t
{
    int commandValueState = 0;
    float commandValue = 0;
    float triggerInputValue = 0.f;
    float playerInputValue = 0.f;
    bool trigger_cmdkeyblock_state = false;  
    std::vector<commandbeam_t> beams;
    std::vector<int> rotators;
    Ogre::String description;
    RoR::CmdKeyInertia rotator_inertia;
    RoR::CmdKeyInertia command_inertia;
};
struct command_t {…};
 
struct hydrobeam_t 
{
    uint16_t  hb_beam_index{0}; 
    float     hb_ref_length{0}; 
    float     hb_speed{0};      
    BitMask_t hb_flags{0};      
    BitMask_t hb_anim_flags{0}; 
    float     hb_anim_param{0}; 
    RoR::CmdKeyInertia  hb_inertia;
};
struct hydrobeam_t  {…};
 
struct rotator_t
{
    bool needs_engine;
    NodeNum_t nodes1[4];
    NodeNum_t nodes2[4];
    NodeNum_t axis1; 
    NodeNum_t axis2;
    float angle;
    float rate;
    float force;
    float tolerance;
    float engine_coupling;
    float debug_rate;
    float debug_aerror;
};
struct rotator_t {…};
 
struct flare_t
{
    NodeNum_t noderef = NODENUM_INVALID;
    NodeNum_t nodex   = NODENUM_INVALID;
    NodeNum_t nodey   = NODENUM_INVALID;
    float offsetx;
    float offsety;
    float offsetz;
    Ogre::SceneNode *snode = nullptr;
    Ogre::BillboardSet *bbs = nullptr; 
    Ogre::Light *light = nullptr;
    FlareType fl_type;
    int controlnumber; 
    int dashboard_link; 
    float blinkdelay;
    float blinkdelay_curr;
    bool blinkdelay_state;
    float size;
    float intensity;
    bool uses_inertia = false; 
    SimpleInertia inertia; 
};
struct flare_t {…};
 
struct PropAnimKeyState
{
    bool eventlock_present = false;
    bool event_active_prev = false;
    bool anim_active = false;
    events event_id = EV_MODE_LAST; // invalid
};
struct PropAnimKeyState {…};
 
class CmdKeyArray
{
public:
    command_t& operator[](int index)
    {
        if (index >= 0 && index <= MAX_COMMANDS) // for backwards compatibility, we accept 0 as index too.
        {
            return m_commandkey[index]; // valid commandkey (indexed 1-MAX_COMMANDS!)
        }
        else if (index < 0)
        {
            return m_virtualkey[index]; // 'virtual' commandkey - if hashmap value doesn't exist, it's inserted automatically.
        }
        else
        {
            assert(false);
            return m_dummykey; // Whatever!
        }
    }
    command_t& operator[](int index) {…}
private:
    std::array<command_t, MAX_COMMANDS + 1> m_commandkey; 
    std::unordered_map<int, command_t> m_virtualkey; 
    command_t m_dummykey;
};
class CmdKeyArray {…};
 
struct UniqueCommandKeyPair
{
    std::string uckp_description;
    CommandkeyID_t uckp_key1 = COMMANDKEYID_INVALID;
    CommandkeyID_t uckp_key2 = COMMANDKEYID_INVALID;
};
struct UniqueCommandKeyPair {…};
 
 
// --------------------------------
// some non-actor structs
 
 
 
 
struct collision_box_t
{
    bool virt;
    bool refined;
    bool selfrotated;
    bool camforced;
    bool enabled;
    CollisionEventFilter event_filter;
    short eventsourcenum;
    Ogre::Vector3 lo;           
    Ogre::Vector3 hi;           
    Ogre::Vector3 center;       
    Ogre::Quaternion rot;       
    Ogre::Quaternion unrot;     
    Ogre::Vector3 selfcenter;   
    Ogre::Quaternion selfrot;   
    Ogre::Quaternion selfunrot; 
    Ogre::Vector3 relo;         
    Ogre::Vector3 rehi;         
    Ogre::Vector3 campos;       
    Ogre::Vector3 debug_verts[8];
    std::string reverb_preset_name; 
};
struct collision_box_t {…};
typedef std::vector<collision_box_t*> CollisionBoxPtrVec;
 
struct ground_model_t
{
    float va;                       
    float ms;                       
    float mc;                       
    float t2;                       
    float vs;                       
    float alpha;                    
    float strength;                 
 
    float fluid_density;            
    float flow_consistency_index;   
 
    float flow_behavior_index;
 
    
    float solid_ground_level;       
    float drag_anisotropy;          
 
    int fx_type;
    Ogre::ColourValue fx_colour;
    char name[256];
    char basename[256];
    char particle_name[256];
 
    int fx_particle_amount;         
 
    float fx_particle_min_velo;     
    float fx_particle_max_velo;     
    float fx_particle_fade;         
    float fx_particle_timedelta;    
    float fx_particle_velo_factor;  
    float fx_particle_ttl;
};
struct ground_model_t {…};
 
 
enum class FreeForceType
{
    DUMMY,               
    CONSTANT,            
    TOWARDS_COORDS,      
    TOWARDS_NODE,        
    HALFBEAM_GENERIC,    
    HALFBEAM_ROPE,       
};
enum class FreeForceType {…};
 
struct FreeForce
{
    // Common params:
    FreeForceID_t        ffc_id = FREEFORCEID_INVALID;
    FreeForceType        ffc_type = FreeForceType::DUMMY;
    float                ffc_force_magnitude = 0.f;
    ActorPtr             ffc_base_actor;
    NodeNum_t            ffc_base_node = NODENUM_INVALID;
    // Direction-specific params:
    Ogre::Vector3        ffc_force_const_direction = Ogre::Vector3::ZERO; 
    Ogre::Vector3        ffc_target_coords = Ogre::Vector3::ZERO;
    ActorPtr             ffc_target_actor;
    NodeNum_t            ffc_target_node = NODENUM_INVALID;
    // Half-beam specific params:
    float                ffc_halfb_spring = DEFAULT_SPRING;
    float                ffc_halfb_damp = DEFAULT_DAMP;
    float                ffc_halfb_deform = BEAM_DEFORM;
    float                ffc_halfb_strength = BEAM_BREAK; 
    float                ffc_halfb_diameter = DEFAULT_BEAM_DIAMETER;
    float                ffc_halfb_plastic_coef = BEAM_PLASTIC_COEF_DEFAULT;
    // Half-beam simulation state:
    float                ffc_halfb_L = 0.f; 
    float                ffc_halfb_stress = 0.f;
    float                ffc_halfb_minmaxposnegstress = 0.f;
    float                ffc_halfb_maxposstress = 0.f;
    float                ffc_halfb_maxnegstress = 0.f;
};
struct FreeForce {…};
 
struct FreeForceRequest
{
    // AngelScript `dictionary` converts all primitives to `double` or `int64`, see 'scriptdictionary.cpp', function `Set()`
    
    // common params:
    int64_t ffr_id = FREEFORCEID_INVALID;
    int64_t ffr_type = (int64_t)FreeForceType::DUMMY;
    double ffr_force_magnitude = 0.0;
    int64_t ffr_base_actor = ACTORINSTANCEID_INVALID;
    int64_t ffr_base_node = NODENUM_INVALID;
    // direction-specific params:
    Ogre::Vector3 ffr_force_const_direction = Ogre::Vector3::ZERO;
    Ogre::Vector3 ffr_target_coords = Ogre::Vector3::ZERO;
    int64_t ffr_target_actor = ACTORINSTANCEID_INVALID;
    int64_t ffr_target_node = NODENUM_INVALID;
    // Half-beam specific params:
    double ffr_halfb_spring = DEFAULT_SPRING;
    double ffr_halfb_damp = DEFAULT_DAMP;
    double ffr_halfb_deform = BEAM_DEFORM;
    double ffr_halfb_strength = BEAM_DEFORM;
    double ffr_halfb_diameter = DEFAULT_BEAM_DIAMETER;
    double ffr_halfb_plastic_coef = BEAM_PLASTIC_COEF_DEFAULT;
};
struct FreeForceRequest {…};
 
 
struct authorinfo_t
{
    int id;
    Ogre::String type;
    Ogre::String name;
    Ogre::String email;
};
struct authorinfo_t {…};
 
struct ActorSpawnRequest
{
    ActorSpawnRequest();
    ~ActorSpawnRequest();
 
    enum class Origin 
    {
        UNKNOWN,
        CONFIG_FILE,  
        TERRN_DEF,    
        USER,         
        SAVEGAME,     
        NETWORK,      
        AI            
    };
    enum class Origin  {…};
 
    ActorInstanceID_t   asr_instance_id = ACTORINSTANCEID_INVALID; 
    CacheEntryPtr       asr_cache_entry; 
    std::string         asr_filename;    
    Ogre::String        asr_config;
    Ogre::Vector3       asr_position = Ogre::Vector3::ZERO;
    Ogre::Quaternion    asr_rotation = Ogre::Quaternion::ZERO;
    collision_box_t*    asr_spawnbox = nullptr;
    CacheEntryPtr       asr_skin_entry;
    CacheEntryPtr       asr_tuneup_entry; 
    TuneupDefPtr        asr_working_tuneup; 
    Origin              asr_origin = Origin::UNKNOWN;
    int                 asr_debugview = 0; //(int)DebugViewType::DEBUGVIEW_NONE;
    std::string     asr_net_username;
    int                 asr_net_color = 0;
    BitMask_t           asr_net_peeropts = BitMask_t(0); 
    int                 net_source_id = 0;
    int                 net_stream_id = 0;
    bool                asr_free_position = false;   
    bool                asr_enter = true;
    bool                asr_terrn_machine = false;   
    std::shared_ptr<rapidjson::Document>
                        asr_saved_state;             
};
struct ActorSpawnRequest {…};
 
struct ActorModifyRequest
{
    ActorModifyRequest();
    ~ActorModifyRequest();
 
    enum class Type
    {
        INVALID,
        RELOAD,               
        RESET_ON_INIT_POS,
        RESET_ON_SPOT,
        SOFT_RESPAWN, 
        SOFT_RESET,
        RESTORE_SAVED,
        WAKE_UP,
        REFRESH_VISUALS 
    };
    enum class Type {…};
 
    ActorInstanceID_t   amr_actor = ACTORINSTANCEID_INVALID;// not ActorPtr because it's not thread-safe
    Type                amr_type;
    std::shared_ptr<rapidjson::Document>
                        amr_saved_state;
    CacheEntryPtr       amr_addonpart; 
    std::string         amr_addonpart_fname; 
    Ogre::Vector3       amr_softrespawn_position; 
    Ogre::Quaternion    amr_softrespawn_rotation; 
};
struct ActorModifyRequest {…};
 
enum class ActorLinkingRequestType
{
    INVALID,
    LOAD_SAVEGAME,
    // hookToggle()
    HOOK_LOCK,
    HOOK_UNLOCK,
    HOOK_TOGGLE,
    HOOK_MOUSE_TOGGLE,
    HOOK_RESET,
    // tieToggle()
    TIE_TOGGLE,
    TIE_RESET,
    // ropeToggle()
    ROPE_TOGGLE,
    ROPE_RESET,
    // toggleSlideNodeLock()
    SLIDENODE_TOGGLE
};
enum class ActorLinkingRequestType {…};
 
struct ActorLinkingRequest
{
    ActorInstanceID_t alr_actor_instance_id = ACTORINSTANCEID_INVALID;
    ActorLinkingRequestType alr_type = ActorLinkingRequestType::INVALID;
    // hookToggle()
    int alr_hook_group = -1;
    NodeNum_t alr_hook_mousenode = NODENUM_INVALID;
    // tieToggle()
    int alr_tie_group = -1;
    // ropeToggle()
    int alr_rope_group = -1;
};
struct ActorLinkingRequest {…};
 
enum ActorSimAttr
{
    ACTORSIMATTR_NONE,
 
    // TractionControl
    ACTORSIMATTR_TC_RATIO, 
    ACTORSIMATTR_TC_PULSE_TIME, 
    ACTORSIMATTR_TC_WHEELSLIP_CONSTANT, 
 
    // Engine
    ACTORSIMATTR_ENGINE_SHIFTDOWN_RPM, 
    ACTORSIMATTR_ENGINE_SHIFTUP_RPM, 
    ACTORSIMATTR_ENGINE_TORQUE, 
    ACTORSIMATTR_ENGINE_DIFF_RATIO, 
    ACTORSIMATTR_ENGINE_GEAR_RATIOS_ARRAY, 
 
    // Engoption
    ACTORSIMATTR_ENGOPTION_ENGINE_INERTIA, 
    ACTORSIMATTR_ENGOPTION_ENGINE_TYPE, 
    ACTORSIMATTR_ENGOPTION_CLUTCH_FORCE, 
    ACTORSIMATTR_ENGOPTION_SHIFT_TIME, 
    ACTORSIMATTR_ENGOPTION_CLUTCH_TIME, 
    ACTORSIMATTR_ENGOPTION_POST_SHIFT_TIME, 
    ACTORSIMATTR_ENGOPTION_STALL_RPM, 
    ACTORSIMATTR_ENGOPTION_IDLE_RPM, 
    ACTORSIMATTR_ENGOPTION_MAX_IDLE_MIXTURE, 
    ACTORSIMATTR_ENGOPTION_MIN_IDLE_MIXTURE, 
    ACTORSIMATTR_ENGOPTION_BRAKING_TORQUE, 
 
    // Engturbo2 (actually 'engturbo' with Param #1 [type] set to "2" - the recommended variant)
    ACTORSIMATTR_ENGTURBO2_INERTIA_FACTOR, 
    ACTORSIMATTR_ENGTURBO2_NUM_TURBOS, 
    ACTORSIMATTR_ENGTURBO2_MAX_RPM, 
    ACTORSIMATTR_ENGTURBO2_ENGINE_RPM_OP, 
    ACTORSIMATTR_ENGTURBO2_BOV_ENABLED, 
    ACTORSIMATTR_ENGTURBO2_BOV_MIN_PSI, 
    ACTORSIMATTR_ENGTURBO2_WASTEGATE_ENABLED, 
    ACTORSIMATTR_ENGTURBO2_WASTEGATE_MAX_PSI, 
    ACTORSIMATTR_ENGTURBO2_WASTEGATE_THRESHOLD_N, 
    ACTORSIMATTR_ENGTURBO2_WASTEGATE_THRESHOLD_P, 
    ACTORSIMATTR_ENGTURBO2_ANTILAG_ENABLED, 
    ACTORSIMATTR_ENGTURBO2_ANTILAG_CHANCE, 
    ACTORSIMATTR_ENGTURBO2_ANTILAG_MIN_RPM, 
    ACTORSIMATTR_ENGTURBO2_ANTILAG_POWER, 
 
};
enum ActorSimAttr {…};
const char* ActorSimAttrToString(ActorSimAttr attr);
 
} // namespace RoR