de/deb/_actor_8h_source.html

/*

    This source file is part of Rigs of Rods

    Copyright 2005-2012 Pierre-Michel Ricordel

    Copyright 2007-2012 Thomas Fischer

    Copyright 2016-2024 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 "CmdKeyInertia.h"

#include "Differentials.h"

#include "Engine.h"

#include "GfxActor.h"

#include "PerVehicleCameraContext.h"

#include "RigDef_Prerequisites.h"

#include "RoRnet.h"

#include "RefCountingObject.h"

#include "RefCountingObjectPtr.h"

#include "SimData.h"

#include "SoundScriptManager.h"

#include "TyrePressure.h"

#include "VehicleAI.h"


#include <Ogre.h>


namespace RoR {


class Actor : public RefCountingObject<Actor>

{

    friend class ActorSpawner;

    friend class ActorManager;

    friend class GfxActor; // Temporary until all visuals are moved there. ~ only_a_ptr, 2018

    friend class OutGauge;

public:


    Actor(

          ActorInstanceID_t actor_id

        , unsigned int vector_index

        , RigDef::DocumentPtr def

        , ActorSpawnRequest rq

        );


    virtual ~Actor() override;


    void              dispose();


    void              sendStreamSetup();

    void              sendStreamData();

    void              pushNetwork(char* data, int size);

    void              calcNetwork();


    // PLEASE maintain the same order as in 'scripting/bindings/ActorAngelscript.cpp' and 'doc/angelscript/.../BeamClass.h'

    ActorState        getTruckState() { return ar_state; }

    Ogre::Vector3     getPosition();

    // AngelScript alias: `getVehiclePosition()`

    float             getRotation();

    // AngelScript alias: `getHeadingDirectionAngle()`

    Ogre::Quaternion  getOrientation();

    float             getSpeed() { return m_avg_node_velocity.length(); };

    Ogre::Vector3     getGForces() { return m_camera_local_gforces_cur; };

    float             getTotalMass(bool withLocked=true);

    int               getNodeCount() { return ar_num_nodes; }

    Ogre::Vector3     getNodePosition(int nodeNumber);

    bool              isNodeWheelRim(int nodeNumber);

    bool              isNodeWheelTire(int nodeNumber);

    int               getWheelNodeCount() const;

    float             getWheelSpeed() const { return ar_wheel_speed; }

    void              reset(bool keep_position = false);

    float             getShockSpringRate(int shock_number);

    float             getShockDamping(int shock_number);

    float             getShockVelocity(int shock_number);

    int               getShockNode1(int shock_number);

    int               getShockNode2(int shock_number);

    // not exported to scripting:

    void              resetPosition(Ogre::Vector3 translation, bool setInitPosition);

    void              resetPosition(float px, float pz, bool setInitPosition, float miny);

    void              softRespawn(Ogre::Vector3 spawnpos, Ogre::Quaternion spawnrot);

    void              requestRotation(float rotation, Ogre::Vector3 center) { m_rotation_request += rotation; m_rotation_request_center = center; };

    void              requestAngleSnap(int division) { m_anglesnap_request = division; };

    void              requestTranslation(Ogre::Vector3 translation) { m_translation_request += translation; };

    int               getShockCount() { return ar_num_shocks; }

    Ogre::Vector3     getVelocity() const { return m_avg_node_velocity; };

    Ogre::Vector3     getDirection();

    Ogre::Vector3     getRotationCenter();

    float             getMinHeight(bool skip_virtual_nodes=true);

    float             getMaxHeight(bool skip_virtual_nodes=true);

    float             getHeightAboveGround(bool skip_virtual_nodes=true);

    float             getHeightAboveGroundBelow(float height, bool skip_virtual_nodes=true);

    Ogre::Vector3     getMaxGForces() { return m_camera_local_gforces_max; };

    bool              hasSlidenodes() { return !m_slidenodes.empty(); };

    void              updateSlideNodePositions();

    void              updateSlideNodeForces(const Ogre::Real delta_time_sec);

    void              resetSlideNodePositions();

    void              resetSlideNodes();


    // PLEASE maintain the same order as in 'scripting/bindings/ActorAngelscript.cpp' and 'doc/angelscript/.../BeamClass.h'

    void              scaleTruck(float value);

    void              setMass(float m);

    void              setLoadedMass(float m);

    void              setSimAttribute(ActorSimAttr attr, float val);

    float             getSimAttribute(ActorSimAttr attr);

    // not exported to scripting:

    void              applyNodeBeamScales();

    void              searchBeamDefaults();

    void              updateInitPosition();

    void              propagateNodeBeamChangesToDef();

    void              recalculateNodeMasses();


    // PLEASE maintain the same order as in 'scripting/bindings/ActorAngelscript.cpp' and 'doc/angelscript/.../BeamClass.h'

    void              parkingbrakeToggle();

    void              tractioncontrolToggle();

    void              antilockbrakeToggle();

    void              toggleCustomParticles();

    bool              getCustomParticleMode();

    bool              isLocked();

    void              setForcedCinecam(CineCameraID_t cinecam_id, BitMask_t flags);

    void              clearForcedCinecam();

    bool              getForcedCinecam(CineCameraID_t& cinecam_id, BitMask_t& flags);

    int               getNumCinecams() { return ar_num_cinecams; }

    // not exported to scripting:

    void              mouseMove(NodeNum_t node, Ogre::Vector3 pos, float force);

    void              tieToggle(int group=-1, ActorLinkingRequestType mode=ActorLinkingRequestType::TIE_TOGGLE, ActorInstanceID_t forceunlock_filter=ACTORINSTANCEID_INVALID);

    bool              isTied();

    void              hookToggle(int group=-1, ActorLinkingRequestType mode=ActorLinkingRequestType::HOOK_TOGGLE,NodeNum_t mousenode=NODENUM_INVALID, ActorInstanceID_t forceunlock_filter=ACTORINSTANCEID_INVALID);

    void              ropeToggle(int group=-1, ActorLinkingRequestType mode=ActorLinkingRequestType::ROPE_TOGGLE, ActorInstanceID_t forceunlock_filter=ACTORINSTANCEID_INVALID);

    void              engineTriggerHelper(int engineNumber, EngineTriggerType type, float triggerValue);

    void              toggleSlideNodeLock();

    bool              getParkingBrake() { return ar_parking_brake; }

    void              cruisecontrolToggle();

    void              toggleAxleDiffMode();

    void              displayAxleDiffMode();

    int               getAxleDiffMode() { return m_num_axle_diffs; }

    void              toggleWheelDiffMode();

    void              displayWheelDiffMode();

    int               getWheelDiffMode() { return m_num_wheel_diffs; }

    void              toggleTransferCaseMode();

    TransferCase*     getTransferCaseMode() { return m_transfer_case; }

    void              toggleTransferCaseGearRatio();

    Ogre::String      getTransferCaseName();

    void              displayTransferCaseMode();

    void              setSmokeEnabled(bool enabled) { m_disable_smoke = !enabled; }

    bool              getSmokeEnabled() const { return !m_disable_smoke; }


    // PLEASE maintain the same order as in 'scripting/bindings/ActorAngelscript.cpp' and 'doc/angelscript/.../BeamClass.h'

    BlinkType         getBlinkType();

    void              setBlinkType(BlinkType blink);

    void              toggleBlinkType(BlinkType blink);

    bool              getCustomLightVisible(int number);

    void              setCustomLightVisible(int number, bool visible);

    bool              getBeaconMode() const { return m_lightmask & RoRnet::LIGHTMASK_BEACONS; }

    void              beaconsToggle();

    bool              getBrakeLightVisible() const { return m_lightmask & RoRnet::LIGHTMASK_BRAKES; }

    bool              getReverseLightVisible() const { return m_lightmask & RoRnet::LIGHTMASK_REVERSE; }

    int               countCustomLights(int control_number);

    int               countFlaresByType(FlareType type);

    // not exported to scripting:

    void              toggleHeadlights();

    BitMask_t         getLightStateMask() const { return m_lightmask; }

    void              setLightStateMask(BitMask_t lightmask);

    void              importLightStateMask(BitMask_t lightmask);

    bool              getSideLightsVisible() const { return m_lightmask & RoRnet::LIGHTMASK_SIDELIGHTS; }

    void              setSideLightsVisible(bool val) { BITMASK_SET(m_lightmask, RoRnet::LIGHTMASK_SIDELIGHTS, val); }

    bool              getHeadlightsVisible() const { return m_lightmask & RoRnet::LIGHTMASK_HEADLIGHT; }

    void              setHeadlightsVisible(bool val) { if (val != this->getHeadlightsVisible()) { this->toggleHeadlights(); } }

    bool              getHighBeamsVisible() const { return m_lightmask & RoRnet::LIGHTMASK_HIGHBEAMS; }

    void              setHighBeamsVisible(bool val) { BITMASK_SET(m_lightmask, RoRnet::LIGHTMASK_HIGHBEAMS, val); }

    bool              getFogLightsVisible() const { return m_lightmask & RoRnet::LIGHTMASK_FOGLIGHTS; }

    void              setFogLightsVisible(bool val) { BITMASK_SET(m_lightmask, RoRnet::LIGHTMASK_FOGLIGHTS, val); }

    void              setBeaconMode(bool val) { BITMASK_SET(m_lightmask, RoRnet::LIGHTMASK_BEACONS, val); }


    void              updateSkidmarks();

    void              prepareInside(bool inside);

    void              updateFlareStates(float dt);

    void              updateVisual(float dt=0);

    void              updateDashBoards(float dt);

    void              forceAllFlaresOff();


    void              updateSoundSources();

    void              muteAllSounds();

    void              unmuteAllSounds();


    VehicleAIPtr      getVehicleAI() { return ar_vehicle_ai; }

    Ogre::MaterialPtr        getManagedMaterialInstance(const std::string& orig_name);

    std::vector<std::string> getManagedMaterialNames();

    // not exported to scripting:

    Replay*           getReplay();

    TyrePressure&     getTyrePressure() { return m_tyre_pressure; }

    EnginePtr      getEngine() { return ar_engine; }


    // PLEASE maintain the same ordering as in 'scripting/bindings/ActorAngelscript.cpp' and 'doc/angelscript/.../BeamClass.h'

    std::string       getTruckName() { return ar_design_name; }

    std::string       getTruckFileName() { return ar_filename; }

    std::string       getTruckFileResourceGroup();

    int               getTruckType() { return ar_driveable; }

    Ogre::String      getSectionConfig() { return m_section_config; }

    int               getInstanceId() { return ar_instance_id; }

    // not exported to scripting:

    CacheEntryPtr&    getUsedActorEntry();

    CacheEntryPtr&    getUsedSkinEntry();

    TuneupDefPtr&     getWorkingTuneupDef();

    void              ensureWorkingTuneupDef();

    void              removeWorkingTuneupDef();

    bool              isPreloadedWithTerrain() const { return m_preloaded_with_terrain; };

    std::vector<authorinfo_t> getAuthors();

    std::vector<std::string>  getDescription();


    void              ForceFeedbackStep(int steps);

    void              HandleInputEvents(float dt);

    void              HandleAngelScriptEvents(float dt);

    void              UpdateCruiseControl(float dt);

    bool              Intersects(ActorPtr actor, Ogre::Vector3 offset = Ogre::Vector3::ZERO);

    void              resolveCollisions(Ogre::Vector3 direction);

    void              resolveCollisions(float max_distance, bool consider_up);

    float             getSteeringAngle();

    float             getMinCameraRadius() { return m_min_camera_radius; };

    int               GetNumActiveConnectedBeams(int nodeid);

    void              NotifyActorCameraChanged();

    float             getAvgPropedWheelRadius() { return m_avg_proped_wheel_radius; };

    void              setAirbrakeIntensity(float intensity);

    void              UpdateBoundingBoxes();

    void              calculateAveragePosition();

    void              UpdatePhysicsOrigin();

    void              SoftReset();

    void              SyncReset(bool reset_position);

    void              WriteDiagnosticDump(std::string const& filename);

    Ogre::Vector3     GetCameraDir()                    { return (ar_nodes[ar_main_camera_node_pos].RelPosition - ar_nodes[ar_main_camera_node_dir].RelPosition).normalisedCopy(); }

    Ogre::Vector3     GetCameraRoll()                   { return (ar_nodes[ar_main_camera_node_pos].RelPosition - ar_nodes[ar_main_camera_node_roll].RelPosition).normalisedCopy(); }

    Ogre::Vector3     GetFFbBodyForces() const          { return m_force_sensors.out_body_forces; }

    GfxActor*         GetGfxActor()                     { return m_gfx_actor.get(); }

    void              RequestUpdateHudFeatures()        { m_hud_features_ok = false; }

    Ogre::Real        getMinimalCameraRadius();

    float             GetFFbHydroForces() const         { return m_force_sensors.out_hydros_forces; }

    bool              isBeingReset() const              { return m_ongoing_reset; };

    void              UpdatePropAnimInputEvents();


    // -------------------- Public data -------------------- //


    float             ar_dry_mass = 0.f;

    float             ar_original_dry_mass = 0.f;

    float             ar_load_mass = 0.f;

    float             ar_original_load_mass = 0.f;

    int               ar_masscount = 0;

    float             ar_total_mass = 0.f;

    float             ar_initial_total_mass = 0.f;


    // Node data (split to layers)

    node_t*              ar_nodes = nullptr;

    int*                 ar_nodes_id = nullptr;

    std::string*         ar_nodes_name = nullptr;

    std::vector<float>   ar_nodes_default_loadweights;

    std::vector<float>   ar_nodes_override_loadweights;

    Ogre::Vector3*       ar_nodes_spawn_offsets = nullptr;

    std::vector<BitMask_t> ar_nodes_options;

    std::vector<float>   ar_minimass;

    std::vector<float>   ar_orig_minimass;

    std::vector<float>   ar_initial_node_masses;

    std::vector<Ogre::Vector3> ar_initial_node_positions;


    // Node additional info

    bool                 ar_minimass_skip_loaded_nodes = false;

    int                  ar_nodes_name_top_length = 0;

    int                  ar_num_nodes = 0;


    // Beam data (split to layers)

    beam_t*              ar_beams = nullptr;

    int                  ar_num_beams = 0;

    std::vector<std::pair<float, float>> ar_initial_beam_defaults;

    std::vector<bool>    ar_beams_invisible;

    std::vector<bool>    ar_beams_user_defined;


    std::vector<beam_t*> ar_inter_beams;

    shock_t*             ar_shocks = nullptr;

    int                  ar_num_shocks = 0;

    bool                 ar_has_active_shocks = false;

    rotator_t*           ar_rotators = nullptr;

    int                  ar_num_rotators = 0;

    wing_t*              ar_wings = nullptr;

    int                  ar_num_wings = 0;

    std::vector<authorinfo_t> authors;

    std::vector<rope_t>       ar_ropes;

    std::vector<ropable_t>    ar_ropables;

    std::vector<tie_t>        ar_ties;

    std::vector<hook_t>       ar_hooks;

    std::vector<flare_t>      ar_flares;

    std::vector<Airbrake*>    ar_airbrakes;

    CmdKeyArray               ar_command_key;

    Ogre::AxisAlignedBox      ar_bounding_box;

    Ogre::AxisAlignedBox      ar_evboxes_bounding_box;

    Ogre::AxisAlignedBox      ar_predicted_bounding_box;


    std::vector<wheeldetacher_t>   ar_wheeldetachers;

    std::vector<std::vector<int>>  ar_node_to_node_connections;

    std::vector<std::vector<int>>  ar_node_to_beam_connections;

    std::vector<Ogre::AxisAlignedBox>  ar_collision_bounding_boxes;

    std::vector<Ogre::AxisAlignedBox>  ar_predicted_coll_bounding_boxes;

    std::map<std::string, Ogre::MaterialPtr>  ar_managed_materials;

    std::vector<UniqueCommandKeyPair> ar_unique_commandkey_pairs;


    int               ar_num_contactable_nodes = 0;

    int               ar_num_contacters = 0;

    wheel_t           ar_wheels[MAX_WHEELS] = {};

    int               ar_num_wheels = 0;

    soundsource_t     ar_soundsources[MAX_SOUNDSCRIPTS_PER_TRUCK] = {};

    int               ar_num_soundsources = 0;

    AeroEngine*       ar_aeroengines[MAX_AEROENGINES] = {};

    int               ar_num_aeroengines = 0;

    Screwprop*        ar_screwprops[MAX_SCREWPROPS] = {};

    int               ar_num_screwprops = 0;

    int               ar_cabs[MAX_CABS * 3] = {};

    int               ar_num_cabs = 0;

    std::vector<hydrobeam_t> ar_hydros;

    int               ar_collcabs[MAX_CABS] = {};

    collcab_rate_t    ar_inter_collcabrate[MAX_CABS] = {};

    collcab_rate_t    ar_intra_collcabrate[MAX_CABS] = {};

    int               ar_num_collcabs = 0;

    int               ar_buoycabs[MAX_CABS] = {};

    int               ar_buoycab_types[MAX_CABS] = {};

    int               ar_num_buoycabs = 0;

    NodeNum_t         ar_camera_rail[MAX_CAMERARAIL] = {};

    int               ar_num_camera_rails = 0;

    bool              ar_hide_in_actor_list = false;

    Ogre::String      ar_design_name;

    float             ar_anim_previous_crank = 0.f;

    float             alb_ratio = 0.f;

    float             alb_minspeed = 0.f;

    bool              alb_mode = false;

    float             alb_pulse_time = 0.f;

    bool              alb_pulse_state = false;

    bool              alb_nodash = false;

    bool              alb_notoggle = false;

    float             alb_timer = 0.f;

    float             ar_anim_shift_timer = 0.f;

    bool              cc_mode = false;

    bool              cc_can_brake = false;

    float             cc_target_rpm = 0.f;

    float             cc_target_speed = 0.f;

    float             cc_target_speed_lower_limit = 0.f;

    std::deque<float> cc_accs;

    bool              sl_enabled = false;

    float             sl_speed_limit = 0.f;

    ExtCameraMode     ar_extern_camera_mode = ExtCameraMode::CLASSIC;

    NodeNum_t         ar_extern_camera_node = NODENUM_INVALID;

    NodeNum_t         ar_exhaust_pos_node   = 0;

    NodeNum_t         ar_exhaust_dir_node   = 0;

    ActorInstanceID_t ar_instance_id = ACTORINSTANCEID_INVALID;

    unsigned int      ar_vector_index = 0;

    ActorType         ar_driveable = NOT_DRIVEABLE;

    EnginePtr         ar_engine;

    NodeNum_t         ar_cinecam_node[MAX_CAMERAS] = {NODENUM_INVALID};

    int               ar_num_cinecams = 0;

    Autopilot*        ar_autopilot = nullptr;

    float             ar_brake_force = 0.f;


    Ogre::Vector3     ar_origin = Ogre::Vector3::ZERO;

    int               ar_num_cameras = 0;

    Ogre::Quaternion  ar_main_camera_dir_corr = Ogre::Quaternion::IDENTITY;

    NodeNum_t         ar_main_camera_node_pos            = 0;

    NodeNum_t         ar_main_camera_node_dir            = 0;

    NodeNum_t         ar_main_camera_node_roll           = 0;

    NodeNum_t         ar_camera_node_pos[MAX_CAMERAS]    = {NODENUM_INVALID};

    NodeNum_t         ar_camera_node_dir[MAX_CAMERAS]    = {NODENUM_INVALID};

    NodeNum_t         ar_camera_node_roll[MAX_CAMERAS]   = {NODENUM_INVALID};

    bool              ar_camera_node_roll_inv[MAX_CAMERAS] = {false};


    float             ar_posnode_spawn_height = 0.f;

    VehicleAIPtr      ar_vehicle_ai;

    float             ar_scale = 1.f;

    Ogre::Real        ar_brake = 0.f;

    float             ar_wheel_speed = 0.f;

    float             ar_wheel_spin = 0.f;

    float             ar_avg_wheel_speed = 0.f;

    float             ar_hydro_dir_command = 0.f;

    float             ar_hydro_dir_state = 0.f;

    Ogre::Real        ar_hydro_dir_wheel_display = 0.f;

    float             ar_hydro_aileron_command = 0.f;

    float             ar_hydro_aileron_state = 0.f;

    float             ar_hydro_rudder_command = 0.f;

    float             ar_hydro_rudder_state = 0.f;

    float             ar_hydro_elevator_command = 0.f;

    float             ar_hydro_elevator_state = 0.f;

    float             ar_sleep_counter = 0.f;

    ground_model_t*   ar_submesh_ground_model = nullptr;

    bool              ar_parking_brake = false;

    bool              ar_trailer_parking_brake = false;

    float             ar_left_mirror_angle = 0.52f;

    float             ar_right_mirror_angle = -0.52f;

    float             ar_elevator = 0.f;

    float             ar_rudder = 0.f;

    float             ar_aileron = 0.f;

    int               ar_aerial_flap = 0;

    Ogre::Vector3     ar_fusedrag = Ogre::Vector3::ZERO;

    std::string       ar_filename;

    std::string       ar_filehash;

    int               ar_airbrake_intensity = 0;

    int               ar_net_source_id = 0;

    int               ar_net_stream_id = 0;

    std::map<int,int> ar_net_stream_results;

    Ogre::Timer       ar_net_timer;

    unsigned long     ar_net_last_update_time = 0;

    DashBoardManager* ar_dashboard = nullptr;

    float             ar_collision_range = DEFAULT_COLLISION_RANGE;

    float             ar_top_speed = 0.f;

    ground_model_t*   ar_last_fuzzy_ground_model = nullptr;

    CollisionBoxPtrVec m_potential_eventboxes;

    std::vector<std::pair<collision_box_t*, NodeNum_t>> m_active_eventboxes;


    // Player camera 'cameras & cinecam'

    // * 'cinecam#' creates dedicated node to dictate camera position + 6 attachment beams.

    // * 'camera#' specifies a reference frame for the cinecam by referencing 3 preexisting nodes: ref, x, y.

    // NOTE camera#0 is special - serves a general orientation frame for the whole actor. Cinecam#0 isn't required to exist, but camera#0 is.

    CineCameraID_t    ar_current_cinecam = CINECAMERAID_INVALID;

    NodeNum_t         ar_custom_camera_node = NODENUM_INVALID;

    PerVehicleCameraContext ar_camera_context;

    CineCameraID_t    ar_forced_cinecam = CINECAMERAID_INVALID;

    BitMask_t         ar_forced_cinecam_flags = 0;


    // TractionControl

    float             tc_ratio = 0.f;

    bool              tc_mode = false;

    float             tc_pulse_time = 0.f;

    bool              tc_pulse_state = 0.f;

    bool              tc_nodash = false;

    bool              tc_notoggle = false;

    float             tc_timer = 0.f;

    float             tc_wheelslip_constant = 0.25f;


    // Guisettings

    bool              ar_guisettings_use_engine_max_rpm = false;

    float             ar_guisettings_speedo_max_kph = 0.f;

    float             ar_guisettings_shifter_anim_time = 0.4f;


    // Gameplay state

    ActorState        ar_state = ActorState::LOCAL_SIMULATED;

    ActorPtrVec       ar_linked_actors;

    bool              m_ongoing_reset = false;

    bool              ar_physics_paused = false;

    bool              ar_muted_by_peeropt = false;


    // Repair state

    Ogre::Vector3     m_rotation_request_center = Ogre::Vector3::ZERO;

    float             m_rotation_request = 0.f;

    int               m_anglesnap_request = 0;

    Ogre::Vector3     m_translation_request = Ogre::Vector3::ZERO;


    // Realtime node/beam structure editing helpers

    bool                    ar_nb_initialized = false;

    std::vector<float>      ar_nb_optimum;

    std::vector<float>      ar_nb_reference;

    int                     ar_nb_skip_steps = 0;

    int                     ar_nb_measure_steps = 500;

    float                   ar_nb_minimass_scale = 1.f;

    std::pair<float, float> ar_nb_beams_scale;

    std::pair<float, float> ar_nb_shocks_scale;

    std::pair<float, float> ar_nb_wheels_scale;

    std::pair<float, float> ar_nb_beams_d_interval;

    std::pair<float, float> ar_nb_beams_k_interval;

    std::pair<float, float> ar_nb_shocks_d_interval;

    std::pair<float, float> ar_nb_shocks_k_interval;

    std::pair<float, float> ar_nb_wheels_d_interval;

    std::pair<float, float> ar_nb_wheels_k_interval;


    // Bit flags

    bool ar_update_physics:1;

    bool ar_disable_aerodyn_turbulent_drag:1;

    bool ar_engine_hydraulics_ready:1;

    bool ar_hydro_speed_coupling:1;

    bool ar_collision_relevant:1;

    bool ar_is_police:1;

    bool ar_rescuer_flag:1;

    bool ar_forward_commands:1;

    bool ar_import_commands:1;

    bool ar_toggle_ropes:1;

    bool ar_toggle_ties:1;

    bool ar_cparticles_active:1;


private:


    bool              CalcForcesEulerPrepare(bool doUpdate);

    void              CalcAircraftForces(bool doUpdate);

    void              CalcForcesEulerCompute(bool doUpdate, int num_steps);

    void              CalcAnimators(hydrobeam_t const& hydrobeam, float &cstate, int &div);

    void              CalcBeams(bool trigger_hooks);

    void              CalcBeamsInterActor();

    void              CalcBuoyance(bool doUpdate);

    void              CalcCommands(bool doUpdate);

    void              CalcCabCollisions();

    void              CalcDifferentials();

    void              CalcForceFeedback(bool doUpdate);

    void              CalcFuseDrag();

    void              CalcHooks();

    void              CalcHydros();

    void              CalcMouse();

    void              CalcNodes();

    void              CalcEventBoxes();

    void              CalcReplay();

    void              CalcRopes();

    void              CalcShocks(bool doUpdate, int num_steps);

    void              CalcShocks2(int i, Ogre::Real difftoBeamL, Ogre::Real &k, Ogre::Real &d, Ogre::Real v);

    void              CalcShocks3(int i, Ogre::Real difftoBeamL, Ogre::Real &k, Ogre::Real &d, Ogre::Real v);

    void              CalcTriggers(int i, Ogre::Real difftoBeamL, bool update_hooks);

    void              CalcTies();

    void              CalcTruckEngine(bool doUpdate);

    void              CalcWheels(bool doUpdate, int num_steps);


    void              DetermineLinkedActors();

    void              calcNodeConnectivityGraph();

    void              AddInterActorBeam(beam_t* beam, ActorPtr other, ActorLinkingRequestType type);

    void              RemoveInterActorBeam(beam_t* beam, ActorLinkingRequestType type);

    void              DisjoinInterActorBeams();

    void              autoBlinkReset();

    void              ResetAngle(float rot);

    void              calculateLocalGForces();

    //  Both PointColDetectors need to be updated accordingly before calling this

    Ogre::Vector3     calculateCollisionOffset(Ogre::Vector3 direction);

    std::pair<RailGroup*, Ogre::Real> GetClosestRailOnActor( ActorPtr actor, const SlideNode& node);


    // -------------------- data -------------------- //


    std::vector<std::shared_ptr<Task>> m_flexbody_tasks;

    RigDef::DocumentPtr                m_definition;

    std::unique_ptr<GfxActor>          m_gfx_actor;

    Ogre::String                       m_section_config;

    std::vector<SlideNode>             m_slidenodes;

    std::vector<RailGroup*>            m_railgroups;

    std::vector<Ogre::Entity*>         m_deletion_entities;

    std::vector<Ogre::SceneNode*>      m_deletion_scene_nodes;

    int               m_proped_wheel_pairs[MAX_WHEELS] = {};

    int               m_num_proped_wheels = 0;

    float             m_avg_proped_wheel_radius = 0.f;

    float             m_avionic_chatter_timer = 11.f;

    PointColDetector* m_inter_point_col_detector = nullptr;

    PointColDetector* m_intra_point_col_detector = nullptr;


    Ogre::Vector3     m_avg_node_position = Ogre::Vector3::ZERO;

    Ogre::Real        m_min_camera_radius = 0.f;

    Ogre::Vector3     m_avg_node_position_prev = Ogre::Vector3::ZERO;

    Ogre::Vector3     m_avg_node_velocity = Ogre::Vector3::ZERO;

    float             m_stabilizer_shock_sleep = 0.f;

    Replay*           m_replay_handler = nullptr;

    NodeNum_t         m_mouse_grab_node = NODENUM_INVALID;

    Ogre::Vector3     m_mouse_grab_pos = Ogre::Vector3::ZERO;

    float             m_mouse_grab_move_force = 0.f;

    float             m_spawn_rotation = 0.f;

    Ogre::Timer       m_reset_timer;

    Ogre::Vector3     m_camera_gforces_accu = Ogre::Vector3::ZERO;

    Ogre::Vector3     m_camera_gforces = Ogre::Vector3::ZERO;

    Ogre::Vector3     m_camera_local_gforces_cur = Ogre::Vector3::ZERO;

    Ogre::Vector3     m_camera_local_gforces_max = Ogre::Vector3::ZERO;

    float             m_stabilizer_shock_ratio = 0.f;

    int               m_stabilizer_shock_request = 0;

    Differential*     m_axle_diffs[1+MAX_WHEELS/2] = {};

    int               m_num_axle_diffs = 0;

    Differential*     m_wheel_diffs[MAX_WHEELS/2] = {};

    int               m_num_wheel_diffs = 0;

    TransferCase*     m_transfer_case = nullptr;

    int               m_wheel_node_count = 0;

    int               m_previous_gear = 0;

    float             m_handbrake_force = 0.f;

    Airfoil*          m_fusealge_airfoil = nullptr;

    node_t*           m_fusealge_front = nullptr;

    node_t*           m_fusealge_back = nullptr;

    float             m_fusealge_width = 0.f;

    float             m_odometer_total = 0.f;

    float             m_odometer_user = 0.f;

    int               m_num_command_beams = 0;

    std::unique_ptr<Buoyance> m_buoyance;

    CacheEntryPtr     m_used_actor_entry;

    CacheEntryPtr     m_used_skin_entry;

    TuneupDefPtr      m_working_tuneup_def;

    Skidmark*         m_skid_trails[MAX_WHEELS*2] = {};

    bool              m_antilockbrake = false;

    bool              m_tractioncontrol = false;

    bool              m_has_axles_section = false;

    TyrePressure      m_tyre_pressure;

    std::vector<std::string>  m_description;

    std::vector<PropAnimKeyState> m_prop_anim_key_states;


    size_t            m_net_node_buf_size = 0;

    size_t            m_net_wheel_buf_size = 0;

    size_t            m_net_propanimkey_buf_size = 0;

    size_t            m_net_total_buffer_size = 0;

    float             m_net_node_compression = 0.f;

    int               m_net_first_wheel_node = 0;


    std::string       m_net_username;

    int               m_net_color_num = 0;


    GfxFlaresMode     m_flares_mode = GfxFlaresMode::NONE;

    BitMask_t         m_lightmask = 0;

    BitMask_t         m_flaregroups_no_import = 0;

    bool              m_blinker_autoreset = false;

    bool              m_blinker_left_lit = false;

    bool              m_blinker_right_lit = false;


    bool m_hud_features_ok:1;

    bool m_slidenodes_locked:1;

    bool m_net_initialized:1;

    bool m_water_contact:1;

    bool m_water_contact_old:1;

    bool m_has_command_beams:1;

    bool m_preloaded_with_terrain:1;

    bool m_beam_break_debug_enabled:1;

    bool m_beam_deform_debug_enabled:1;

    bool m_trigger_debug_enabled:1;

    bool m_disable_default_sounds:1;

    bool m_disable_smoke:1;


    struct VehicleForceSensors

    {

        inline void Reset()

        {

            accu_body_forces    = Ogre::Vector3::ZERO;

            accu_hydros_forces  = 0;

            out_body_forces     = Ogre::Vector3::ZERO;

            out_hydros_forces   = 0;

        };


        Ogre::Vector3 accu_body_forces;

        float         accu_hydros_forces;

        Ogre::Vector3 out_body_forces;

        float         out_hydros_forces;

    } m_force_sensors;


    struct NetUpdate

    {

        std::vector<char> veh_state;

        std::vector<char> node_data;

        std::vector<float> wheel_data;

    };


    std::deque<NetUpdate> m_net_updates;

};


} // namespace RoR