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 "AeroEngine.h"

#include "Application.h"

#include "AutoPilot.h"

#include "CmdKeyInertia.h"

#include "DashBoardManager.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 "ScrewProp.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);

    float             getDryMass() { return ar_dry_mass; }

    float             getLoadedMass() { return ar_load_mass; }

    float             getInitialDryMass() { return ar_original_dry_mass; }

    float             getInitialLoadedMass() { return ar_original_load_mass; }

    int               getNodeCount() { return ar_num_nodes; }

    Ogre::Vector3     getNodePosition(int nodeNumber);

    float             getNodeInitialMass(int nodeNumber);

    float             getNodeMass(int nodeNumber);

    Ogre::Vector3     getNodeVelocity(int nodeNumber);

    Ogre::Vector3     getNodeForces(int nodeNumber);

    void              getNodeMassOptions(int nodeNumber, bool& loaded, bool& overrideMass);

    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);

    float             getAirbrakeIntensity() { return ar_airbrake_intensity; }

    int               getAircraftFlaps() { return ar_aerial_flap; }

    // 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              setNodeMass(int nodeNumber, float m);

    void              setNodeMassOptions(int nodeNumber, bool loaded, bool overrideMass);

    void              setSimAttribute(ActorSimAttr attr, float val);

    float             getSimAttribute(ActorSimAttr attr);

    void              recalculateNodeMasses();

    void              setAirbrakeIntensity(float intensity);

    void              setAircraftFlaps(int flapsLevel);

    // not exported to scripting:

    void              applyNodeBeamScales();

    void              searchBeamDefaults();

    void              updateInitPosition();

    void              propagateNodeBeamChangesToDef();


    // 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();


    DashBoardManagerPtr         getDashboardManager() { return ar_dashboard; }

    VehicleAIPtr                getVehicleAI() { return ar_vehicle_ai; }

    int                         getAircraftEngineCount() { return ar_num_aeroengines; };

    AeroEnginePtr               getAircraftEngine(int index);

    AeroEnginePtr               getTurbojet(int index);

    AeroEnginePtr               getTurboprop(int index);

    AutopilotPtr                getAutopilot() { return ar_autopilot; };

    int                         getScrewpropCount() { return ar_num_screwprops; };

    ScrewpropPtr                getScrewprop(int index);

    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();

    CacheEntryPtrVec& getUsedAddonpartEntries();

    CacheEntryPtrVec& getUsedAssetpackEntries();

    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              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;

    AeroEnginePtr     ar_aeroengines[MAX_AEROENGINES] = {};

    int               ar_num_aeroengines = 0;

    ScrewpropPtr      ar_screwprops[MAX_SCREWPROPS] = {};

    int               ar_num_screwprops = 0;

    int               ar_cabs[MAX_CABS * 3] = {};

    BuoyCachedNodeID_t ar_cabs_buoy_cache_ids[MAX_CABS] = {};

    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;

    AutopilotPtr      ar_autopilot;

    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;

    DashBoardManagerPtr ar_dashboard;

    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;

    std::unique_ptr<Buoyance> m_buoyance;


    // 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;

    std::unique_ptr<GfxActor>          m_gfx_actor;

    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;


    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;


    std::string       m_section_config;

    TuneupDefPtr      m_working_tuneup_def;

    // cache entries

    CacheEntryPtr     m_used_actor_entry;

    CacheEntryPtr     m_used_skin_entry;

    CacheEntryPtrVec  m_used_addonpart_entries;

    CacheEntryPtrVec  m_used_assetpack_entries;


    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;

        };

        inline void Reset() {…}


        Ogre::Vector3 accu_body_forces;

        float         accu_hydros_forces;

        Ogre::Vector3 out_body_forces;

        float         out_hydros_forces;

    } m_force_sensors;

    struct VehicleForceSensors {…};


    struct NetUpdate

    {

        std::vector<char> veh_state;

        std::vector<char> node_data;

        std::vector<float> wheel_data;

    };

    struct NetUpdate {…};


    std::deque<NetUpdate> m_net_updates;

};

class Actor : public RefCountingObject<Actor> {…};


} // namespace RoR

AeroEngine.h

Application.h
Central state/object manager and communications hub.

AutoPilot.h

BITMASK_SET
void BITMASK_SET(BitMask_t &mask, BitMask_t flag, bool val)
Definition BitFlags.h:19

BitMask_t
uint32_t BitMask_t
Definition BitFlags.h:7

CmdKeyInertia.h

DashBoardManager.h

Differentials.h

Engine.h

GfxActor.h
Manager for all visuals belonging to a single actor.

PerVehicleCameraContext.h

RefCountingObject.h

RefCountingObjectPtr.h

RigDef_Prerequisites.h

ScrewProp.h

MAX_CABS
static const int MAX_CABS
maximum number of cabs per actor
Definition SimConstants.h:27

MAX_CAMERAS
static const int MAX_CAMERAS
maximum number of cameras per actor
Definition SimConstants.h:29

MAX_AEROENGINES
static const int MAX_AEROENGINES
maximum number of aero engines per actor
Definition SimConstants.h:30

MAX_WHEELS
static const int MAX_WHEELS
maximum number of wheels per actor
Definition SimConstants.h:24

MAX_SOUNDSCRIPTS_PER_TRUCK
static const int MAX_SOUNDSCRIPTS_PER_TRUCK
maximum number of soundsscripts per actor
Definition SimConstants.h:32

MAX_CAMERARAIL
static const int MAX_CAMERARAIL
maximum number of camera rail points
Definition SimConstants.h:34

MAX_SCREWPROPS
static const int MAX_SCREWPROPS
maximum number of boat screws per actor
Definition SimConstants.h:31

SimData.h
Core data structures for simulation; Everything affected by by either physics, network or user intera...

SoundScriptManager.h

TyrePressure.h
Wheel 'pressure adjustment' logic (only for 'wheels2')

VehicleAI.h
Simple waypoint AI.

RefCountingObject
Self reference-counting objects, as requred by AngelScript garbage collector.
Definition RefCountingObject.h:27

RefCountingObjectPtr< DashBoardManager >

RoR::Actor
Softbody object; can be anything from soda can to a space shuttle Constructed from a truck definition...
Definition Actor.h:55

RoR::Actor::ar_hydro_speed_coupling
bool ar_hydro_speed_coupling
Definition Actor.h:551

RoR::Actor::ar_parking_brake
bool ar_parking_brake
Definition Actor.h:467

RoR::Actor::getTransferCaseName
Ogre::String getTransferCaseName()
Toggles between Hi and Lo mode.
Definition Actor.cpp:1536

RoR::Actor::alb_mode
bool alb_mode
Anti-lock brake state; Enabled? {1/0}.
Definition Actor.h:410

RoR::Actor::getBlinkType
BlinkType getBlinkType()
Definition Actor.cpp:4609

RoR::Actor::ar_nb_wheels_k_interval
std::pair< float, float > ar_nb_wheels_k_interval
Search interval for springiness & damping of wheel / rim beams.
Definition Actor.h:545

RoR::Actor::m_odometer_user
float m_odometer_user
GUI state.
Definition Actor.h:652

RoR::Actor::ar_node_to_beam_connections
std::vector< std::vector< int > > ar_node_to_beam_connections
Definition Actor.h:376

RoR::Actor::ar_wings
wing_t * ar_wings
Definition Actor.h:360

RoR::Actor::ar_num_screwprops
int ar_num_screwprops
Definition Actor.h:391

RoR::Actor::ar_num_wings
int ar_num_wings
Definition Actor.h:361

RoR::Actor::getInitialLoadedMass
float getInitialLoadedMass()
Definition Actor.h:96

RoR::Actor::setHighBeamsVisible
void setHighBeamsVisible(bool val)
Definition Actor.h:221

RoR::Actor::ar_forced_cinecam_flags
BitMask_t ar_forced_cinecam_flags
Sim state; flags for forced CineCam supplied by script.
Definition Actor.h:500

RoR::Actor::ar_import_commands
bool ar_import_commands
Sim state.
Definition Actor.h:556

RoR::Actor::ar_nb_shocks_k_interval
std::pair< float, float > ar_nb_shocks_k_interval
Search interval for springiness & damping of shock beams.
Definition Actor.h:543

RoR::Actor::ar_orig_minimass
std::vector< float > ar_orig_minimass
minimum node mass in Kg - original unscaled values
Definition Actor.h:338

RoR::Actor::ar_custom_camera_node
NodeNum_t ar_custom_camera_node
Sim state; custom tracking node for 3rd-person camera.
Definition Actor.h:497

RoR::Actor::ar_bounding_box
Ogre::AxisAlignedBox ar_bounding_box
standard bounding box (surrounds all nodes of an actor)
Definition Actor.h:370

RoR::Actor::getTruckState
ActorState getTruckState()
Definition Actor.h:84

RoR::Actor::ar_nb_measure_steps
int ar_nb_measure_steps
Amount of physics steps to be measured.
Definition Actor.h:535

RoR::Actor::m_wheel_node_count
int m_wheel_node_count
Static attr; filled at spawn.
Definition Actor.h:644

RoR::Actor::m_num_command_beams
int m_num_command_beams
TODO: Remove! Spawner context only; likely unused feature.
Definition Actor.h:653

RoR::Actor::ar_update_physics
bool ar_update_physics
Physics state; Should this actor be updated (locally) in the next physics step?
Definition Actor.h:548

RoR::Actor::m_net_total_buffer_size
size_t m_net_total_buffer_size
For incoming/outgoing traffic; calculated on spawn.
Definition Actor.h:678

RoR::Actor::ar_engine
EnginePtr ar_engine
Definition Actor.h:432

RoR::Actor::requestAngleSnap
void requestAngleSnap(int division)
Definition Actor.h:121

RoR::Actor::resetSlideNodePositions
void resetSlideNodePositions()
Recalculate SlideNode positions.
Definition ActorSlideNode.cpp:112

RoR::Actor::ar_collision_range
float ar_collision_range
Physics attr.
Definition Actor.h:485

RoR::Actor::CalcTies
void CalcTies()
Definition ActorForcesEuler.cpp:1122

RoR::Actor::updateSlideNodeForces
void updateSlideNodeForces(const Ogre::Real delta_time_sec)
calculate and apply Corrective forces
Definition ActorSlideNode.cpp:103

RoR::Actor::m_antilockbrake
bool m_antilockbrake
GUI state.
Definition Actor.h:656

RoR::Actor::ar_predicted_coll_bounding_boxes
std::vector< Ogre::AxisAlignedBox > ar_predicted_coll_bounding_boxes
Definition Actor.h:378

RoR::Actor::getLightStateMask
BitMask_t getLightStateMask() const
Definition Actor.h:213

RoR::Actor::ar_minimass
std::vector< float > ar_minimass
minimum node mass in Kg - can be scaled in-game via NBUtil
Definition Actor.h:337

RoR::Actor::m_transfer_case
TransferCase * m_transfer_case
Physics.
Definition Actor.h:643

RoR::Actor::ar_guisettings_speedo_max_kph
float ar_guisettings_speedo_max_kph
Definition Actor.h:514

RoR::Actor::ar_dry_mass
float ar_dry_mass
User-defined (editable via NBUtil); from 'globals' arg#1 - default for all nodes.
Definition Actor.h:320

RoR::Actor::CalcCommands
void CalcCommands(bool doUpdate)
Definition ActorForcesEuler.cpp:807

RoR::Actor::ar_net_stream_results
std::map< int, int > ar_net_stream_results
Definition Actor.h:481

RoR::Actor::ar_airbrake_intensity
int ar_airbrake_intensity
Physics state; values 0-5.
Definition Actor.h:478

RoR::Actor::toggleTransferCaseGearRatio
void toggleTransferCaseGearRatio()
Definition Actor.cpp:1522

RoR::Actor::m_blinker_left_lit
bool m_blinker_left_lit
Blinking state of left turn signal.
Definition Actor.h:692

RoR::Actor::ar_hydro_elevator_state
float ar_hydro_elevator_state
Definition Actor.h:464

RoR::Actor::ar_nb_beams_scale
std::pair< float, float > ar_nb_beams_scale
Scales for springiness & damping of regular beams.
Definition Actor.h:537

RoR::Actor::ar_forward_commands
bool ar_forward_commands
Sim state.
Definition Actor.h:555

RoR::Actor::m_proped_wheel_pairs
int m_proped_wheel_pairs[MAX_WHEELS]
Physics attr; For inter-differential locking.
Definition Actor.h:615

RoR::Actor::toggleSlideNodeLock
void toggleSlideNodeLock()
Definition ActorSlideNode.cpp:34

RoR::Actor::engineTriggerHelper
void engineTriggerHelper(int engineNumber, EngineTriggerType type, float triggerValue)
Definition Actor.cpp:4401

RoR::Actor::resetSlideNodes
void resetSlideNodes()
Reset all the SlideNodes.
Definition ActorSlideNode.cpp:122

RoR::Actor::getUsedSkinEntry
CacheEntryPtr & getUsedSkinEntry()
Definition Actor.cpp:4878

RoR::Actor::antilockbrakeToggle
void antilockbrakeToggle()
Definition Actor.cpp:3831

RoR::Actor::m_ongoing_reset
bool m_ongoing_reset
Hack to prevent position/rotation creep during interactive truck reset (aka LiveRepair).
Definition Actor.h:520

RoR::Actor::ar_camera_node_dir
NodeNum_t ar_camera_node_dir[MAX_CAMERAS]
Physics attr; 'camera' = frame of reference; back node.
Definition Actor.h:445

RoR::Actor::calcNodeConnectivityGraph
void calcNodeConnectivityGraph()
Definition Actor.cpp:907

RoR::Actor::CalcBeams
void CalcBeams(bool trigger_hooks)
Definition ActorForcesEuler.cpp:1210

RoR::Actor::m_mouse_grab_move_force
float m_mouse_grab_move_force
Definition Actor.h:630

RoR::Actor::sendStreamData
void sendStreamData()
Send outgoing data.
Definition Actor.cpp:2026

RoR::Actor::ar_wheel_speed
float ar_wheel_speed
Physics state; wheel speed in m/s.
Definition Actor.h:453

RoR::Actor::updateSkidmarks
void updateSkidmarks()
Creates or updates skidmarks.
Definition Actor.cpp:2999

RoR::Actor::ar_intra_collcabrate
collcab_rate_t ar_intra_collcabrate[MAX_CABS]
Definition Actor.h:398

RoR::Actor::m_net_initialized
bool m_net_initialized
Definition Actor.h:698

RoR::Actor::ar_nodes_override_loadweights
std::vector< float > ar_nodes_override_loadweights
'nodes': 'l' flag and number.
Definition Actor.h:334

RoR::Actor::GetClosestRailOnActor
std::pair< RailGroup *, Ogre::Real > GetClosestRailOnActor(ActorPtr actor, const SlideNode &node)
Definition ActorSlideNode.cpp:73

RoR::Actor::getUsedAddonpartEntries
CacheEntryPtrVec & getUsedAddonpartEntries()
Definition Actor.cpp:4883

RoR::Actor::ar_evboxes_bounding_box
Ogre::AxisAlignedBox ar_evboxes_bounding_box
bounding box around nodes eligible for eventbox triggering
Definition Actor.h:371

RoR::Actor::ar_filehash
std::string ar_filehash
Attribute; filled at spawn.
Definition Actor.h:477

RoR::Actor::ar_nb_minimass_scale
float ar_nb_minimass_scale
scale of 'set_default_minimass' (affects all nodes the same way)
Definition Actor.h:536

RoR::Actor::GetNumActiveConnectedBeams
int GetNumActiveConnectedBeams(int nodeid)
Returns the number of active (non bounded) beams connected to a node.
Definition Actor.cpp:3913

RoR::Actor::ar_beams_invisible
std::vector< bool > ar_beams_invisible
Used only by the exporter (for rendering, invisible beams simply get no mesh).
Definition Actor.h:351

RoR::Actor::ar_ropables
std::vector< ropable_t > ar_ropables
Definition Actor.h:364

RoR::Actor::ar_cabs_buoy_cache_ids
BuoyCachedNodeID_t ar_cabs_buoy_cache_ids[MAX_CABS]
Definition Actor.h:393

RoR::Actor::ar_top_speed
float ar_top_speed
Sim state.
Definition Actor.h:486

RoR::Actor::ar_command_key
CmdKeyArray ar_command_key
BEWARE: commandkeys are indexed 1-MAX_COMMANDS!
Definition Actor.h:369

RoR::Actor::CalcHooks
void CalcHooks()
Definition ActorForcesEuler.cpp:1787

RoR::Actor::ar_wheels
wheel_t ar_wheels[MAX_WHEELS]
Definition Actor.h:384

RoR::Actor::ar_nb_reference
std::vector< float > ar_nb_reference
Temporary storage of the reference search result.
Definition Actor.h:533

RoR::Actor::ar_ropes
std::vector< rope_t > ar_ropes
Definition Actor.h:363

RoR::Actor::getNumCinecams
int getNumCinecams()
Definition Actor.h:171

RoR::Actor::hookToggle
void hookToggle(int group=-1, ActorLinkingRequestType mode=ActorLinkingRequestType::HOOK_TOGGLE, NodeNum_t mousenode=NODENUM_INVALID, ActorInstanceID_t forceunlock_filter=ACTORINSTANCEID_INVALID)
Definition Actor.cpp:3677

RoR::Actor::m_mouse_grab_node
NodeNum_t m_mouse_grab_node
Sim state; node currently being dragged by user.
Definition Actor.h:628

RoR::Actor::ar_dashboard
DashBoardManagerPtr ar_dashboard
Definition Actor.h:484

RoR::Actor::m_odometer_total
float m_odometer_total
GUI state.
Definition Actor.h:651

RoR::Actor::getSimAttribute
float getSimAttribute(ActorSimAttr attr)
Definition Actor.cpp:5018

RoR::Actor::ar_wheeldetachers
std::vector< wheeldetacher_t > ar_wheeldetachers
Definition Actor.h:374

RoR::Actor::getScrewpropCount
int getScrewpropCount()
Definition Actor.h:253

RoR::Actor::CalcDifferentials
void CalcDifferentials()
Definition ActorForcesEuler.cpp:231

RoR::Actor::prepareInside
void prepareInside(bool inside)
Prepares vehicle for in-cabin camera use.
Definition Actor.cpp:3023

RoR::Actor::displayTransferCaseMode
void displayTransferCaseMode()
Gets the current transfer case mode name (4WD Hi, ...)
Definition Actor.cpp:1477

RoR::Actor::ar_camera_node_roll_inv
bool ar_camera_node_roll_inv[MAX_CAMERAS]
Physics attr; 'camera' = frame of reference; indicates roll node is right instead of left.
Definition Actor.h:447

RoR::Actor::getWheelSpeed
float getWheelSpeed() const
Definition Actor.h:107

RoR::Actor::ar_num_camera_rails
int ar_num_camera_rails
Definition Actor.h:404

RoR::Actor::getWheelNodeCount
int getWheelNodeCount() const
Definition Actor.cpp:902

RoR::Actor::getMaxHeight
float getMaxHeight(bool skip_virtual_nodes=true)
Definition Actor.cpp:1581

RoR::Actor::tc_pulse_time
float tc_pulse_time
Definition Actor.h:505

RoR::Actor::getCustomParticleMode
bool getCustomParticleMode()
Definition Actor.cpp:4617

RoR::Actor::getNodeVelocity
Ogre::Vector3 getNodeVelocity(int nodeNumber)
Definition Actor.cpp:4726

RoR::Actor::ropeToggle
void ropeToggle(int group=-1, ActorLinkingRequestType mode=ActorLinkingRequestType::ROPE_TOGGLE, ActorInstanceID_t forceunlock_filter=ACTORINSTANCEID_INVALID)
Definition Actor.cpp:3600

RoR::Actor::getInitialDryMass
float getInitialDryMass()
Definition Actor.h:95

RoR::Actor::setSmokeEnabled
void setSmokeEnabled(bool enabled)
Writes info to console/notify area.
Definition Actor.h:193

RoR::Actor::ar_nodes
node_t * ar_nodes
Definition Actor.h:330

RoR::Actor::m_camera_gforces
Ogre::Vector3 m_camera_gforces
Physics state (global)
Definition Actor.h:634

RoR::Actor::calcNetwork
void calcNetwork()
Definition Actor.cpp:471

RoR::Actor::ar_aerial_flap
int ar_aerial_flap
Sim state; state of aircraft flaps (values: 0-5)
Definition Actor.h:474

RoR::Actor::beaconsToggle
void beaconsToggle()
Definition Actor.cpp:3849

RoR::Actor::dispose
void dispose()
Effectively destroys the object but keeps it in memory to satisfy shared pointers.
Definition Actor.cpp:89

RoR::Actor::ar_original_load_mass
float ar_original_load_mass
Un-edited value from 'globals' arg#2.
Definition Actor.h:323

RoR::Actor::updateVisual
void updateVisual(float dt=0)
Definition Actor.cpp:3285

RoR::Actor::ar_buoycabs
int ar_buoycabs[MAX_CABS]
Definition Actor.h:400

RoR::Actor::getSpeed
float getSpeed()
Definition Actor.h:90

RoR::Actor::GetGfxActor
GfxActor * GetGfxActor()
Definition Actor.h:309

RoR::Actor::isNodeWheelRim
bool isNodeWheelRim(int nodeNumber)
Is node marked as wheel rim? Note some wheel models use only tire nodes. See https://docs....
Definition Actor.cpp:4764

RoR::Actor::ar_predicted_bounding_box
Ogre::AxisAlignedBox ar_predicted_bounding_box
Definition Actor.h:372

RoR::Actor::setNodeMass
void setNodeMass(int nodeNumber, float m)
Definition Actor.cpp:4522

RoR::Actor::ar_nodes_options
std::vector< BitMask_t > ar_nodes_options
merged options from 'nodes' and 'set_node_defaults'
Definition Actor.h:336

RoR::Actor::ar_design_name
Ogre::String ar_design_name
Name of the vehicle/machine/object this actor represents.
Definition Actor.h:406

RoR::Actor::calculateLocalGForces
void calculateLocalGForces()
Derive the truck local g-forces from the global ones.
Definition Actor.cpp:4379

RoR::Actor::m_num_wheel_diffs
int m_num_wheel_diffs
Physics attr.
Definition Actor.h:642

RoR::Actor::cc_accs
std::deque< float > cc_accs
Cruise Control.
Definition Actor.h:422

RoR::Actor::ar_beams_user_defined
std::vector< bool > ar_beams_user_defined
True for 'beams', false for wheels/cinecam/hooknode/wings/rotators etc...
Definition Actor.h:352

RoR::Actor::ar_muted_by_peeropt
bool ar_muted_by_peeropt
Muted by user in multiplayer (see RoRnet::PEEROPT_MUTE_ACTORS).
Definition Actor.h:522

RoR::Actor::getDashboardManager
DashBoardManagerPtr getDashboardManager()
Definition Actor.h:246

RoR::Actor::updateFlareStates
void updateFlareStates(float dt)
Definition Actor.cpp:3092

RoR::Actor::getRotation
float getRotation()
Definition Actor.cpp:355

RoR::Actor::m_num_proped_wheels
int m_num_proped_wheels
Physics attr, filled at spawn - Number of propelled wheels.
Definition Actor.h:616

RoR::Actor::m_disable_default_sounds
bool m_disable_default_sounds
Spawner context; TODO: remove.
Definition Actor.h:706

RoR::Actor::isTied
bool isTied()
Definition Actor.cpp:3924

RoR::Actor::m_deletion_scene_nodes
std::vector< Ogre::SceneNode * > m_deletion_scene_nodes
For unloading vehicle; filled at spawn.
Definition Actor.h:614

RoR::Actor::getHighBeamsVisible
bool getHighBeamsVisible() const
Definition Actor.h:220

RoR::Actor::m_camera_local_gforces_max
Ogre::Vector3 m_camera_local_gforces_max
Physics state (camera local)
Definition Actor.h:636

RoR::Actor::CalcForceFeedback
void CalcForceFeedback(bool doUpdate)
Definition ActorForcesEuler.cpp:69

RoR::Actor::GetFFbBodyForces
Ogre::Vector3 GetFFbBodyForces() const
Definition Actor.h:308

RoR::Actor::ar_ties
std::vector< tie_t > ar_ties
Definition Actor.h:365

RoR::Actor::m_avg_node_velocity
Ogre::Vector3 m_avg_node_velocity
average node velocity (compared to the previous frame step)
Definition Actor.h:625

RoR::Actor::m_tyre_pressure
TyrePressure m_tyre_pressure
Definition Actor.h:659

RoR::Actor::NotifyActorCameraChanged
void NotifyActorCameraChanged()
Logic: sound, display; Notify this vehicle that camera changed;.
Definition Actor.cpp:3893

RoR::Actor::ar_hydro_rudder_state
float ar_hydro_rudder_state
Definition Actor.h:462

RoR::Actor::ar_sleep_counter
float ar_sleep_counter
Sim state; idle time counter.
Definition Actor.h:465

RoR::Actor::ar_nb_wheels_scale
std::pair< float, float > ar_nb_wheels_scale
Scales for springiness & damping of wheel / rim beams.
Definition Actor.h:539

RoR::Actor::m_water_contact_old
bool m_water_contact_old
Scripting state.
Definition Actor.h:700

RoR::Actor::toggleHeadlights
void toggleHeadlights()
Definition Actor.cpp:3062

RoR::Actor::mouseMove
void mouseMove(NodeNum_t node, Ogre::Vector3 pos, float force)
Definition Actor.cpp:1400

RoR::Actor::m_anglesnap_request
int m_anglesnap_request
Accumulator.
Definition Actor.h:527

RoR::Actor::CalcBuoyance
void CalcBuoyance(bool doUpdate)
Definition ActorForcesEuler.cpp:154

RoR::Actor::ar_original_dry_mass
float ar_original_dry_mass
Un-edited value from 'globals' arg#1.
Definition Actor.h:321

RoR::Actor::m_num_axle_diffs
int m_num_axle_diffs
Physics attr.
Definition Actor.h:640

RoR::Actor::getSmokeEnabled
bool getSmokeEnabled() const
Definition Actor.h:194

RoR::Actor::m_stabilizer_shock_ratio
float m_stabilizer_shock_ratio
Physics state.
Definition Actor.h:637

RoR::Actor::ar_posnode_spawn_height
float ar_posnode_spawn_height
Definition Actor.h:449

RoR::Actor::ar_current_cinecam
CineCameraID_t ar_current_cinecam
Sim state; index of current CineCam (CINECAMERAID_INVALID if using 3rd-person camera)
Definition Actor.h:496

RoR::Actor::ar_submesh_ground_model
ground_model_t * ar_submesh_ground_model
Definition Actor.h:466

RoR::Actor::updateDashBoards
void updateDashBoards(float dt)
Definition Actor.cpp:3940

RoR::Actor::getReplay
Replay * getReplay()
Definition Actor.cpp:4663

RoR::Actor::CalcShocks
void CalcShocks(bool doUpdate, int num_steps)
Definition ActorForcesEuler.cpp:561

RoR::Actor::m_slidenodes
std::vector< SlideNode > m_slidenodes
all the SlideNodes available on this actor
Definition Actor.h:611

RoR::Actor::tc_wheelslip_constant
float tc_wheelslip_constant
use ACTORSIMATTR_TC_WHEELSLIP_CONSTANT
Definition Actor.h:510

RoR::Actor::DisjoinInterActorBeams
void DisjoinInterActorBeams()
Helper for MSG_ handlers, do not invoke by hand.
Definition Actor.cpp:3458

RoR::Actor::importLightStateMask
void importLightStateMask(BitMask_t lightmask)
Only for linked (locked/tied) actors forwarding flare states; see 'flaregroups_no_import' in ....
Definition Actor.cpp:3247

RoR::Actor::m_slidenodes_locked
bool m_slidenodes_locked
Physics state; Are SlideNodes locked?
Definition Actor.h:697

RoR::Actor::clearForcedCinecam
void clearForcedCinecam()
Definition Actor.cpp:5074

RoR::Actor::ar_initial_total_mass
float ar_initial_total_mass
Calculated; total mass in Kg (snapshot at spawn)
Definition Actor.h:326

RoR::Actor::ar_nodes_id
int * ar_nodes_id
Number in truck file, -1 for nodes generated by wheels/cinecam.
Definition Actor.h:331

RoR::Actor::updateInitPosition
void updateInitPosition()
Definition Actor.cpp:1285

RoR::Actor::getMinHeight
float getMinHeight(bool skip_virtual_nodes=true)
Definition Actor.cpp:1568

RoR::Actor::m_preloaded_with_terrain
bool m_preloaded_with_terrain
Spawn context (TODO: remove!)
Definition Actor.h:702

RoR::Actor::toggleWheelDiffMode
void toggleWheelDiffMode()
Definition Actor.cpp:1407

RoR::Actor::ar_initial_beam_defaults
std::vector< std::pair< float, float > > ar_initial_beam_defaults
Definition Actor.h:350

RoR::Actor::ar_camera_node_roll
NodeNum_t ar_camera_node_roll[MAX_CAMERAS]
Physics attr; 'camera' = frame of reference; left node.
Definition Actor.h:446

RoR::Actor::m_axle_diffs
Differential * m_axle_diffs[1+MAX_WHEELS/2]
Physics.
Definition Actor.h:639

RoR::Actor::ar_screwprops
ScrewpropPtr ar_screwprops[MAX_SCREWPROPS]
Definition Actor.h:390

RoR::Actor::ar_vector_index
unsigned int ar_vector_index
Sim attr; actor element index in std::vector<m_actors>
Definition Actor.h:430

RoR::Actor::removeWorkingTuneupDef
void removeWorkingTuneupDef()
Deletes the working tuneup def object if it exists.
Definition Actor.cpp:4907

RoR::Actor::getBrakeLightVisible
bool getBrakeLightVisible() const
Definition Actor.h:207

RoR::Actor::m_spawn_rotation
float m_spawn_rotation
Definition Actor.h:631

RoR::Actor::m_net_node_compression
float m_net_node_compression
For incoming/outgoing traffic; calculated on spawn.
Definition Actor.h:679

RoR::Actor::tieToggle
void tieToggle(int group=-1, ActorLinkingRequestType mode=ActorLinkingRequestType::TIE_TOGGLE, ActorInstanceID_t forceunlock_filter=ACTORINSTANCEID_INVALID)
Definition Actor.cpp:3483

RoR::Actor::m_disable_smoke
bool m_disable_smoke
Stops/starts smoke particles (i.e. exhausts, turbojets).
Definition Actor.h:707

RoR::Actor::m_replay_handler
Replay * m_replay_handler
Definition Actor.h:627

RoR::Actor::getParkingBrake
bool getParkingBrake()
Definition Actor.h:180

RoR::Actor::setAirbrakeIntensity
void setAirbrakeIntensity(float intensity)
Definition Actor.cpp:2974

RoR::Actor::ar_main_camera_node_pos
NodeNum_t ar_main_camera_node_pos
Sim attr; ar_camera_node_pos[0] >= 0 ? ar_camera_node_pos[0] : 0.
Definition Actor.h:441

RoR::Actor::ar_nb_initialized
bool ar_nb_initialized
Definition Actor.h:531

RoR::Actor::getRotationCenter
Ogre::Vector3 getRotationCenter()
Definition Actor.cpp:1550

RoR::Actor::ar_is_police
bool ar_is_police
Gfx/sfx attr.
Definition Actor.h:553

RoR::Actor::getSideLightsVisible
bool getSideLightsVisible() const
Definition Actor.h:216

RoR::Actor::ar_airbrakes
std::vector< Airbrake * > ar_airbrakes
Definition Actor.h:368

RoR::Actor::ResetAngle
void ResetAngle(float rot)
Definition Actor.cpp:1263

RoR::Actor::m_beam_break_debug_enabled
bool m_beam_break_debug_enabled
Logging state.
Definition Actor.h:703

RoR::Actor::ar_physics_paused
bool ar_physics_paused
Actor physics individually paused by user.
Definition Actor.h:521

RoR::Actor::ar_left_mirror_angle
float ar_left_mirror_angle
Sim state; rear view mirror angle.
Definition Actor.h:469

RoR::Actor::getTurbojet
AeroEnginePtr getTurbojet(int index)
Definition Actor.cpp:4632

RoR::Actor::getShockNode2
int getShockNode2(int shock_number)
Definition Actor.cpp:4948

RoR::Actor::ar_nodes_default_loadweights
std::vector< float > ar_nodes_default_loadweights
'set_node_defaults': load weight.
Definition Actor.h:333

RoR::Actor::CalcCabCollisions
void CalcCabCollisions()
Definition Actor.cpp:2553

RoR::Actor::getTruckName
std::string getTruckName()
Definition Actor.h:266

RoR::Actor::ar_net_timer
Ogre::Timer ar_net_timer
Definition Actor.h:482

RoR::Actor::toggleBlinkType
void toggleBlinkType(BlinkType blink)
Definition Actor.cpp:3153

RoR::Actor::getShockSpringRate
float getShockSpringRate(int shock_number)
Definition Actor.cpp:4912

RoR::Actor::getPosition
Ogre::Vector3 getPosition()
Definition Actor.cpp:370

RoR::Actor::m_tractioncontrol
bool m_tractioncontrol
GUI state.
Definition Actor.h:657

RoR::Actor::toggleTransferCaseMode
void toggleTransferCaseMode()
Definition Actor.cpp:1491

RoR::Actor::ForceFeedbackStep
void ForceFeedbackStep(int steps)
Definition Actor.cpp:1837

RoR::Actor::ar_toggle_ropes
bool ar_toggle_ropes
Sim state.
Definition Actor.h:557

RoR::Actor::ar_hydro_dir_command
float ar_hydro_dir_command
Definition Actor.h:456

RoR::Actor::getNodeForces
Ogre::Vector3 getNodeForces(int nodeNumber)
Definition Actor.cpp:4738

RoR::Actor::ar_camera_rail
NodeNum_t ar_camera_rail[MAX_CAMERARAIL]
Nodes defining camera-movement spline.
Definition Actor.h:403

RoR::Actor::pushNetwork
void pushNetwork(char *data, int size)
Process incoming data; fills actor's data buffers and flips them. Called by the network thread....
Definition Actor.cpp:383

RoR::Actor::ar_nb_optimum
std::vector< float > ar_nb_optimum
Temporary storage of the optimum search result.
Definition Actor.h:532

RoR::Actor::ar_buoycab_types
int ar_buoycab_types[MAX_CABS]
Definition Actor.h:401

RoR::Actor::m_fusealge_width
float m_fusealge_width
Physics attr; defined in truckfile.
Definition Actor.h:650

RoR::Actor::m_fusealge_airfoil
Airfoil * m_fusealge_airfoil
Physics attr; defined in truckfile.
Definition Actor.h:647

RoR::Actor::ar_elevator
float ar_elevator
Sim state; aerial controller.
Definition Actor.h:471

RoR::Actor::ar_collision_bounding_boxes
std::vector< Ogre::AxisAlignedBox > ar_collision_bounding_boxes
smart bounding boxes, used for determining the state of an actor (every box surrounds only a subset o...
Definition Actor.h:377

RoR::Actor::displayAxleDiffMode
void displayAxleDiffMode()
Cycles through the available inter axle diff modes.
Definition Actor.cpp:1423

RoR::Actor::CalcShocks3
void CalcShocks3(int i, Ogre::Real difftoBeamL, Ogre::Real &k, Ogre::Real &d, Ogre::Real v)
Definition Actor.cpp:2685

RoR::Actor::m_net_color_num
int m_net_color_num
Definition Actor.h:683

RoR::Actor::getAuthors
std::vector< authorinfo_t > getAuthors()
Definition Actor.cpp:4502

RoR::Actor::ar_soundsources
soundsource_t ar_soundsources[MAX_SOUNDSCRIPTS_PER_TRUCK]
Definition Actor.h:386

RoR::Actor::m_fusealge_front
node_t * m_fusealge_front
Physics attr; defined in truckfile.
Definition Actor.h:648

RoR::Actor::ar_initial_node_positions
std::vector< Ogre::Vector3 > ar_initial_node_positions
Absolute world positions, for resetting to pristine state.
Definition Actor.h:340

RoR::Actor::ensureWorkingTuneupDef
void ensureWorkingTuneupDef()
Creates a working tuneup def if it doesn't exist yet.
Definition Actor.cpp:4898

RoR::Actor::ar_nb_wheels_d_interval
std::pair< float, float > ar_nb_wheels_d_interval
Search interval for springiness & damping of wheel / rim beams.
Definition Actor.h:544

RoR::Actor::UpdatePhysicsOrigin
void UpdatePhysicsOrigin()
Definition Actor.cpp:1250

RoR::Actor::displayWheelDiffMode
void displayWheelDiffMode()
Cycles through the available inter wheel diff modes.
Definition Actor.cpp:1451

RoR::Actor::ar_net_source_id
int ar_net_source_id
Unique ID of remote player who spawned this actor.
Definition Actor.h:479

RoR::Actor::CalcHydros
void CalcHydros()
Definition ActorForcesEuler.cpp:616

RoR::Actor::ar_disable_aerodyn_turbulent_drag
bool ar_disable_aerodyn_turbulent_drag
Physics state.
Definition Actor.h:549

RoR::Actor::ar_wheel_spin
float ar_wheel_spin
Physics state; wheel speed in radians/s.
Definition Actor.h:454

RoR::Actor::recalculateNodeMasses
void recalculateNodeMasses()
Definition Actor.cpp:701

RoR::Actor::ar_flares
std::vector< flare_t > ar_flares
Definition Actor.h:367

RoR::Actor::ar_nb_beams_d_interval
std::pair< float, float > ar_nb_beams_d_interval
Search interval for springiness & damping of regular beams.
Definition Actor.h:540

RoR::Actor::tc_mode
bool tc_mode
Enabled?
Definition Actor.h:504

RoR::Actor::m_deletion_entities
std::vector< Ogre::Entity * > m_deletion_entities
For unloading vehicle; filled at spawn.
Definition Actor.h:613

RoR::Actor::m_buoyance
std::unique_ptr< Buoyance > m_buoyance
Definition Actor.h:490

RoR::Actor::getNodeCount
int getNodeCount()
Definition Actor.h:97

RoR::Actor::m_net_username
std::string m_net_username
Definition Actor.h:682

RoR::Actor::ar_num_cabs
int ar_num_cabs
Definition Actor.h:394

RoR::Actor::alb_nodash
bool alb_nodash
Anti-lock brake attribute: Hide the dashboard indicator?
Definition Actor.h:413

RoR::Actor::getAircraftEngine
AeroEnginePtr getAircraftEngine(int index)
Definition Actor.cpp:4627

RoR::Actor::calculateCollisionOffset
Ogre::Vector3 calculateCollisionOffset(Ogre::Vector3 direction)
Virtually moves the actor at most 'direction.length()' meters towards 'direction' trying to resolve a...
Definition Actor.cpp:992

RoR::Actor::setHeadlightsVisible
void setHeadlightsVisible(bool val)
Definition Actor.h:219

RoR::Actor::countFlaresByType
int countFlaresByType(FlareType type)
Definition Actor.cpp:4598

RoR::Actor::sl_enabled
bool sl_enabled
Speed limiter;.
Definition Actor.h:423

RoR::Actor::getManagedMaterialNames
std::vector< std::string > getManagedMaterialNames()
Definition Actor.cpp:4680

RoR::Actor::ar_net_last_update_time
unsigned long ar_net_last_update_time
Definition Actor.h:483

RoR::Actor::ar_extern_camera_mode
ExtCameraMode ar_extern_camera_mode
Definition Actor.h:425

RoR::Actor::getAvgPropedWheelRadius
float getAvgPropedWheelRadius()
Definition Actor.h:299

RoR::Actor::ar_load_mass
float ar_load_mass
User-defined (editable via NBUtil); from 'globals' arg#2 - only applies to nodes with 'l' flag.
Definition Actor.h:322

RoR::Actor::m_fusealge_back
node_t * m_fusealge_back
Physics attr; defined in truckfile.
Definition Actor.h:649

RoR::Actor::ar_right_mirror_angle
float ar_right_mirror_angle
Sim state; rear view mirror angle.
Definition Actor.h:470

RoR::Actor::ar_exhaust_dir_node
NodeNum_t ar_exhaust_dir_node
Old-format exhaust (one per vehicle) backwards direction node.
Definition Actor.h:428

RoR::Actor::setSideLightsVisible
void setSideLightsVisible(bool val)
Definition Actor.h:217

RoR::Actor::ar_masscount
int ar_masscount
Calculated; Number of nodes loaded with l option.
Definition Actor.h:324

RoR::Actor::getHeightAboveGround
float getHeightAboveGround(bool skip_virtual_nodes=true)
Definition Actor.cpp:1594

RoR::Actor::updateSoundSources
void updateSoundSources()
Definition Actor.cpp:3268

RoR::Actor::m_blinker_right_lit
bool m_blinker_right_lit
Blinking state of right turn signal.
Definition Actor.h:693

RoR::Actor::m_inter_point_col_detector
PointColDetector * m_inter_point_col_detector
Physics.
Definition Actor.h:619

RoR::Actor::ar_hydro_elevator_command
float ar_hydro_elevator_command
Definition Actor.h:463

RoR::Actor::m_flaregroups_no_import
BitMask_t m_flaregroups_no_import
RoRnet::Lightmask.
Definition Actor.h:690

RoR::Actor::m_stabilizer_shock_request
int m_stabilizer_shock_request
Physics state; values: { -1, 0, 1 }.
Definition Actor.h:638

RoR::Actor::setSimAttribute
void setSimAttribute(ActorSimAttr attr, float val)
HAZARDOUS - values may not be checked; Pay attention to 'safe values' at each attribute description.
Definition Actor.cpp:4957

RoR::Actor::getAutopilot
AutopilotPtr getAutopilot()
Definition Actor.h:252

RoR::Actor::m_railgroups
std::vector< RailGroup * > m_railgroups
all the available RailGroups for this actor
Definition Actor.h:612

RoR::Actor::getVelocity
Ogre::Vector3 getVelocity() const
Definition Actor.h:124

RoR::Actor::m_handbrake_force
float m_handbrake_force
Physics attr; defined in truckfile.
Definition Actor.h:646

RoR::Actor::ar_hydro_dir_state
float ar_hydro_dir_state
Definition Actor.h:457

RoR::Actor::ar_extern_camera_node
NodeNum_t ar_extern_camera_node
Definition Actor.h:426

RoR::Actor::ar_engine_hydraulics_ready
bool ar_engine_hydraulics_ready
Sim state; does engine have enough RPM to power hydraulics?
Definition Actor.h:550

RoR::Actor::ar_origin
Ogre::Vector3 ar_origin
Physics state; base position for softbody nodes.
Definition Actor.h:438

RoR::Actor::ar_guisettings_shifter_anim_time
float ar_guisettings_shifter_anim_time
Definition Actor.h:515

RoR::Actor::getWheelDiffMode
int getWheelDiffMode()
Writes info to console/notify box.
Definition Actor.h:187

RoR::Actor::getInstanceId
int getInstanceId()
Definition Actor.h:271

RoR::Actor::ar_state
ActorState ar_state
Definition Actor.h:518

RoR::Actor::m_stabilizer_shock_sleep
float m_stabilizer_shock_sleep
Sim state.
Definition Actor.h:626

RoR::Actor::getCustomLightVisible
bool getCustomLightVisible(int number)
Definition Actor.cpp:4539

RoR::Actor::CalcFuseDrag
void CalcFuseDrag()
Definition ActorForcesEuler.cpp:125

RoR::Actor::ar_brake_force
float ar_brake_force
Physics attr; filled at spawn.
Definition Actor.h:436

RoR::Actor::m_net_wheel_buf_size
size_t m_net_wheel_buf_size
For incoming/outgoing traffic; calculated on spawn.
Definition Actor.h:676

RoR::Actor::m_gfx_actor
std::unique_ptr< GfxActor > m_gfx_actor
Definition Actor.h:610

RoR::Actor::RemoveInterActorBeam
void RemoveInterActorBeam(beam_t *beam, ActorLinkingRequestType type)
Do not call directly - use MSG_SIM_ACTOR_LINKING_REQUESTED
Definition Actor.cpp:3405

RoR::Actor::updateSlideNodePositions
void updateSlideNodePositions()
incrementally update the position of all SlideNodes
Definition ActorSlideNode.cpp:130

RoR::Actor::sendStreamSetup
void sendStreamSetup()
Definition Actor.cpp:1996

RoR::Actor::getDirection
Ogre::Vector3 getDirection()
average actor velocity, calculated using the actor positions of the last two frames
Definition Actor.cpp:365

RoR::Actor::getLoadedMass
float getLoadedMass()
Definition Actor.h:94

RoR::Actor::getHeightAboveGroundBelow
float getHeightAboveGroundBelow(float height, bool skip_virtual_nodes=true)
Definition Actor.cpp:1608

RoR::Actor::ar_exhaust_pos_node
NodeNum_t ar_exhaust_pos_node
Old-format exhaust (one per vehicle) emitter node.
Definition Actor.h:427

RoR::Actor::m_translation_request
Ogre::Vector3 m_translation_request
Accumulator.
Definition Actor.h:528

RoR::Actor::m_net_propanimkey_buf_size
size_t m_net_propanimkey_buf_size
For incoming/outgoing traffic; calculated on spawn.
Definition Actor.h:677

RoR::Actor::tc_timer
float tc_timer
Definition Actor.h:509

RoR::Actor::getTransferCaseMode
TransferCase * getTransferCaseMode()
Toggles between 2WD and 4WD mode.
Definition Actor.h:189

RoR::Actor::ar_aeroengines
AeroEnginePtr ar_aeroengines[MAX_AEROENGINES]
Definition Actor.h:388

RoR::Actor::ar_hydro_aileron_command
float ar_hydro_aileron_command
Definition Actor.h:459

RoR::Actor::getTruckFileName
std::string getTruckFileName()
Definition Actor.h:267

RoR::Actor::isBeingReset
bool isBeingReset() const
Definition Actor.h:313

RoR::Actor::ar_num_shocks
int ar_num_shocks
Number of shock absorbers.
Definition Actor.h:356

RoR::Actor::setNodeMassOptions
void setNodeMassOptions(int nodeNumber, bool loaded, bool overrideMass)
Definition Actor.cpp:4530

RoR::Actor::m_avionic_chatter_timer
float m_avionic_chatter_timer
Sound fx state (some pseudo random number, doesn't matter)
Definition Actor.h:618

RoR::Actor::forceAllFlaresOff
void forceAllFlaresOff()
Definition Actor.cpp:3084

RoR::Actor::ar_total_mass
float ar_total_mass
Calculated; total mass in Kg.
Definition Actor.h:325

RoR::Actor::setLightStateMask
void setLightStateMask(BitMask_t lightmask)
Does all the necessary toggling.
Definition Actor.cpp:3224

RoR::Actor::applyNodeBeamScales
void applyNodeBeamScales()
For GUI::NodeBeamUtils.
Definition Actor.cpp:1814

RoR::Actor::propagateNodeBeamChangesToDef
void propagateNodeBeamChangesToDef()
Back-propagates changes done by N/B-utils UI to the def-document.
Definition ActorExport.cpp:127

RoR::Actor::HandleInputEvents
void HandleInputEvents(float dt)
Definition Actor.cpp:1949

RoR::Actor::getNodePosition
Ogre::Vector3 getNodePosition(int nodeNumber)
Returns world position of node.
Definition Actor.cpp:4690

RoR::Actor::ar_hydro_aileron_state
float ar_hydro_aileron_state
Definition Actor.h:460

RoR::Actor::getAxleDiffMode
int getAxleDiffMode()
Writes info to console/notify box.
Definition Actor.h:184

RoR::Actor::ar_num_aeroengines
int ar_num_aeroengines
Definition Actor.h:389

RoR::Actor::ar_anim_shift_timer
float ar_anim_shift_timer
For 'animator' with flag 'shifter'.
Definition Actor.h:416

RoR::Actor::setForcedCinecam
void setForcedCinecam(CineCameraID_t cinecam_id, BitMask_t flags)
Definition Actor.cpp:5068

RoR::Actor::WriteDiagnosticDump
void WriteDiagnosticDump(std::string const &filename)
Definition Actor.cpp:4788

RoR::Actor::SoftReset
void SoftReset()
Definition Actor.cpp:1633

RoR::Actor::CalcMouse
void CalcMouse()
Definition ActorForcesEuler.cpp:94

RoR::Actor::alb_ratio
float alb_ratio
Anti-lock brake attribute: Regulating force.
Definition Actor.h:408

RoR::Actor::cc_target_speed_lower_limit
float cc_target_speed_lower_limit
Cruise Control.
Definition Actor.h:421

RoR::Actor::getManagedMaterialInstance
Ogre::MaterialPtr getManagedMaterialInstance(const std::string &orig_name)
Definition Actor.cpp:4671

RoR::Actor::GetFFbHydroForces
float GetFFbHydroForces() const
Definition Actor.h:312

RoR::Actor::ar_managed_materials
std::map< std::string, Ogre::MaterialPtr > ar_managed_materials
Definition Actor.h:379

RoR::Actor::searchBeamDefaults
void searchBeamDefaults()
Searches for more stable beam defaults.
Definition Actor.cpp:1858

RoR::Actor::ar_num_beams
int ar_num_beams
Definition Actor.h:349

RoR::Actor::getShockVelocity
float getShockVelocity(int shock_number)
Definition Actor.cpp:4930

RoR::Actor::getNodeMassOptions
void getNodeMassOptions(int nodeNumber, bool &loaded, bool &overrideMass)
Definition Actor.cpp:4750

RoR::Actor::requestRotation
void requestRotation(float rotation, Ogre::Vector3 center)
Definition Actor.h:120

RoR::Actor::authors
std::vector< authorinfo_t > authors
Definition Actor.h:362

RoR::Actor::m_beam_deform_debug_enabled
bool m_beam_deform_debug_enabled
Logging state.
Definition Actor.h:704

RoR::Actor::getSteeringAngle
float getSteeringAngle()
Definition Actor.cpp:4497

RoR::Actor::ar_camera_context
PerVehicleCameraContext ar_camera_context
Definition Actor.h:498

RoR::Actor::countCustomLights
int countCustomLights(int control_number)
Definition Actor.cpp:4581

RoR::Actor::getDescription
std::vector< std::string > getDescription()
Definition Actor.cpp:4507

RoR::Actor::UpdatePropAnimInputEvents
void UpdatePropAnimInputEvents()
Definition Actor.cpp:4846

RoR::Actor::toggleAxleDiffMode
void toggleAxleDiffMode()
Definition Actor.cpp:1415

RoR::Actor::ar_instance_id
ActorInstanceID_t ar_instance_id
Static attr; session-unique ID.
Definition Actor.h:429

RoR::Actor::autoBlinkReset
void autoBlinkReset()
Resets the turn signal when the steering wheel is turned back.
Definition Actor.cpp:3195

RoR::Actor::requestTranslation
void requestTranslation(Ogre::Vector3 translation)
Definition Actor.h:122

RoR::Actor::muteAllSounds
void muteAllSounds()
Definition Actor.cpp:3865

RoR::Actor::setCustomLightVisible
void setCustomLightVisible(int number, bool visible)
Definition Actor.cpp:4561

RoR::Actor::ar_rudder
float ar_rudder
Sim state; aerial/marine controller.
Definition Actor.h:472

RoR::Actor::ar_linked_actors
ActorPtrVec ar_linked_actors
BEWARE: Includes indirect links, see DetermineLinkedActors(); Other actors linked using 'hooks/ties/r...
Definition Actor.h:519

RoR::Actor::m_flexbody_tasks
std::vector< std::shared_ptr< Task > > m_flexbody_tasks
Gfx state.
Definition Actor.h:609

RoR::Actor::alb_notoggle
bool alb_notoggle
Anti-lock brake attribute: Disable in-game toggle?
Definition Actor.h:414

RoR::Actor::SyncReset
void SyncReset(bool reset_position)
this one should be called only synchronously (without physics running in background)
Definition Actor.cpp:1657

RoR::Actor::getAircraftEngineCount
int getAircraftEngineCount()
Definition Actor.h:248

RoR::Actor::ar_avg_wheel_speed
float ar_avg_wheel_speed
Physics state; avg wheel speed in m/s.
Definition Actor.h:455

RoR::Actor::m_prop_anim_key_states
std::vector< PropAnimKeyState > m_prop_anim_key_states
Definition Actor.h:661

RoR::Actor::m_has_axles_section
bool m_has_axles_section
Temporary (legacy parsing helper) until central diffs are implemented.
Definition Actor.h:658

RoR::Actor::ar_rotators
rotator_t * ar_rotators
Definition Actor.h:358

RoR::Actor::ar_brake
Ogre::Real ar_brake
Physics state; braking intensity.
Definition Actor.h:452

RoR::Actor::isPreloadedWithTerrain
bool isPreloadedWithTerrain() const
Definition Actor.h:280

RoR::Actor::m_camera_gforces_accu
Ogre::Vector3 m_camera_gforces_accu
Accumulator for 'camera' G-forces.
Definition Actor.h:633

RoR::Actor::ar_minimass_skip_loaded_nodes
bool ar_minimass_skip_loaded_nodes
Definition Actor.h:343

RoR::Actor::ar_filename
std::string ar_filename
Attribute; filled at spawn.
Definition Actor.h:476

RoR::Actor::ar_nodes_name
std::string * ar_nodes_name
Name in truck file, only if defined with 'nodes2'.
Definition Actor.h:332

RoR::Actor::RequestUpdateHudFeatures
void RequestUpdateHudFeatures()
Definition Actor.h:310

RoR::Actor::ar_cparticles_active
bool ar_cparticles_active
Gfx state.
Definition Actor.h:559

RoR::Actor::cc_target_rpm
float cc_target_rpm
Cruise Control.
Definition Actor.h:419

RoR::Actor::CalcShocks2
void CalcShocks2(int i, Ogre::Real difftoBeamL, Ogre::Real &k, Ogre::Real &d, Ogre::Real v)
Definition Actor.cpp:2574

RoR::Actor::ar_camera_node_pos
NodeNum_t ar_camera_node_pos[MAX_CAMERAS]
Physics attr; 'camera' = frame of reference; origin node.
Definition Actor.h:444

RoR::Actor::m_min_camera_radius
Ogre::Real m_min_camera_radius
Definition Actor.h:623

RoR::Actor::~Actor
virtual ~Actor() override
Definition Actor.cpp:82

RoR::Actor::getVehicleAI
VehicleAIPtr getVehicleAI()
Definition Actor.h:247

RoR::Actor::getMaxGForces
Ogre::Vector3 getMaxGForces()
Definition Actor.h:131

RoR::Actor::ar_num_cinecams
int ar_num_cinecams
Sim attr;.
Definition Actor.h:434

RoR::Actor::getBeaconMode
bool getBeaconMode() const
Definition Actor.h:205

RoR::Actor::m_used_actor_entry
CacheEntryPtr m_used_actor_entry
Required.
Definition Actor.h:668

RoR::Actor::m_flares_mode
GfxFlaresMode m_flares_mode
Snapshot of cvar 'gfx_flares_mode' on spawn.
Definition Actor.h:688

RoR::Actor::ar_inter_collcabrate
collcab_rate_t ar_inter_collcabrate[MAX_CABS]
Definition Actor.h:397

RoR::Actor::getTyrePressure
TyrePressure & getTyrePressure()
Definition Actor.h:259

RoR::Actor::m_section_config
std::string m_section_config
Classic 'sectionconfig' in truck file.
Definition Actor.h:665

RoR::Actor::cc_mode
bool cc_mode
Cruise Control.
Definition Actor.h:417

RoR::Actor::isNodeWheelTire
bool isNodeWheelTire(int nodeNumber)
Is node marked as wheel tire? Note some wheel models use only tire nodes. See https://docs....
Definition Actor.cpp:4776

RoR::Actor::CalcAnimators
void CalcAnimators(hydrobeam_t const &hydrobeam, float &cstate, int &div)
Definition Actor.cpp:2164

RoR::Actor::m_wheel_diffs
Differential * m_wheel_diffs[MAX_WHEELS/2]
Physics.
Definition Actor.h:641

RoR::Actor::ar_hide_in_actor_list
bool ar_hide_in_actor_list
Hide in list of spawned actors (available in top menubar). Useful for fixed-place machinery,...
Definition Actor.h:405

RoR::Actor::getAircraftFlaps
int getAircraftFlaps()
Definition Actor.h:115

RoR::Actor::unmuteAllSounds
void unmuteAllSounds()
Definition Actor.cpp:3879

RoR::Actor::m_net_updates
std::deque< NetUpdate > m_net_updates
Incoming stream of NetUpdates.
Definition Actor.h:732

RoR::Actor::alb_pulse_time
float alb_pulse_time
Anti-lock brake attribute;.
Definition Actor.h:411

RoR::Actor::ar_cabs
int ar_cabs[MAX_CABS *3]
Definition Actor.h:392

RoR::Actor::parkingbrakeToggle
void parkingbrakeToggle()
Definition Actor.cpp:3816

RoR::Actor::getMinimalCameraRadius
Ogre::Real getMinimalCameraRadius()
Definition Actor.cpp:4622

RoR::Actor::m_water_contact
bool m_water_contact
Scripting state.
Definition Actor.h:699

RoR::Actor::ar_num_collcabs
int ar_num_collcabs
Definition Actor.h:399

RoR::Actor::ar_hydro_rudder_command
float ar_hydro_rudder_command
Definition Actor.h:461

RoR::Actor::ar_num_nodes
int ar_num_nodes
Definition Actor.h:345

RoR::Actor::CalcAircraftForces
void CalcAircraftForces(bool doUpdate)
Definition ActorForcesEuler.cpp:103

RoR::Actor::m_skid_trails
Skidmark * m_skid_trails[MAX_WHEELS *2]
Definition Actor.h:655

RoR::Actor::tc_pulse_state
bool tc_pulse_state
Definition Actor.h:506

RoR::Actor::ar_inter_beams
std::vector< beam_t * > ar_inter_beams
Beams connecting 2 actors.
Definition Actor.h:354

RoR::Actor::alb_minspeed
float alb_minspeed
Anti-lock brake attribute;.
Definition Actor.h:409

RoR::Actor::CalcRopes
void CalcRopes()
Definition ActorForcesEuler.cpp:1839

RoR::Actor::getMinCameraRadius
float getMinCameraRadius()
Definition Actor.h:296

RoR::Actor::CalcForcesEulerCompute
void CalcForcesEulerCompute(bool doUpdate, int num_steps)
Definition ActorForcesEuler.cpp:46

RoR::Actor::ar_main_camera_dir_corr
Ogre::Quaternion ar_main_camera_dir_corr
Sim attr;.
Definition Actor.h:440

RoR::Actor::m_mouse_grab_pos
Ogre::Vector3 m_mouse_grab_pos
Definition Actor.h:629

RoR::Actor::ar_nb_shocks_scale
std::pair< float, float > ar_nb_shocks_scale
Scales for springiness & damping of shock beams.
Definition Actor.h:538

RoR::Actor::m_has_command_beams
bool m_has_command_beams
Physics attr;.
Definition Actor.h:701

RoR::Actor::setBlinkType
void setBlinkType(BlinkType blink)
Definition Actor.cpp:3161

RoR::Actor::m_description
std::vector< std::string > m_description
Definition Actor.h:660

RoR::Actor::ar_forced_cinecam
CineCameraID_t ar_forced_cinecam
Sim state; index of CineCam forced by script (CINECAMERAID_INVALID if not forced)
Definition Actor.h:499

RoR::Actor::ar_last_fuzzy_ground_model
ground_model_t * ar_last_fuzzy_ground_model
GUI state.
Definition Actor.h:487

RoR::Actor::m_blinker_autoreset
bool m_blinker_autoreset
When true, we're steering and blinker will turn off automatically.
Definition Actor.h:691

RoR::Actor::ar_vehicle_ai
VehicleAIPtr ar_vehicle_ai
Definition Actor.h:450

RoR::Actor::m_lightmask
BitMask_t m_lightmask
RoRnet::Lightmask.
Definition Actor.h:689

RoR::Actor::getTotalMass
float getTotalMass(bool withLocked=true)
Definition Actor.cpp:843

RoR::Actor::getShockNode1
int getShockNode1(int shock_number)
Definition Actor.cpp:4939

RoR::Actor::getShockDamping
float getShockDamping(int shock_number)
Definition Actor.cpp:4921

RoR::Actor::scaleTruck
void scaleTruck(float value)
Definition Actor.cpp:315

RoR::Actor::ar_anim_previous_crank
float ar_anim_previous_crank
For 'animator' with flag 'torque'.
Definition Actor.h:407

RoR::Actor::CalcTriggers
void CalcTriggers(int i, Ogre::Real difftoBeamL, bool update_hooks)
Definition Actor.cpp:2717

RoR::Actor::getSectionConfig
Ogre::String getSectionConfig()
Definition Actor.h:270

RoR::Actor::getTruckFileResourceGroup
std::string getTruckFileResourceGroup()
Definition Actor.cpp:4868

RoR::Actor::ar_fusedrag
Ogre::Vector3 ar_fusedrag
Physics state.
Definition Actor.h:475

RoR::Actor::tc_notoggle
bool tc_notoggle
Disable in-game toggle?
Definition Actor.h:508

RoR::Actor::ar_aileron
float ar_aileron
Sim state; aerial controller.
Definition Actor.h:473

RoR::Actor::getEngine
EnginePtr getEngine()
Definition Actor.h:260

RoR::Actor::HandleAngelScriptEvents
void HandleAngelScriptEvents(float dt)
Definition Actor.cpp:1846

RoR::Actor::getShockCount
int getShockCount()
Definition Actor.h:123

RoR::Actor::ar_autopilot
AutopilotPtr ar_autopilot
Definition Actor.h:435

RoR::Actor::ar_scale
float ar_scale
Physics state; scale of the actor (nominal = 1.0)
Definition Actor.h:451

RoR::Actor::tc_ratio
float tc_ratio
Regulating force.
Definition Actor.h:503

RoR::Actor::alb_timer
float alb_timer
Anti-lock brake state;.
Definition Actor.h:415

RoR::Actor::CalcTruckEngine
void CalcTruckEngine(bool doUpdate)
Definition ActorForcesEuler.cpp:1153

RoR::Actor::CalcEventBoxes
void CalcEventBoxes()
Definition ActorForcesEuler.cpp:1708

RoR::Actor::hasSlidenodes
bool hasSlidenodes()
Definition Actor.h:132

RoR::Actor::ar_num_soundsources
int ar_num_soundsources
Definition Actor.h:387

RoR::Actor::resolveCollisions
void resolveCollisions(Ogre::Vector3 direction)
Moves the actor at most 'direction.length()' meters towards 'direction' to resolve any collisions.
Definition Actor.cpp:1108

RoR::Actor::ar_num_contacters
int ar_num_contacters
Total number of nodes which can selfcontact cabs.
Definition Actor.h:383

RoR::Actor::ar_hydros
std::vector< hydrobeam_t > ar_hydros
Definition Actor.h:395

RoR::Actor::ar_nodes_name_top_length
int ar_nodes_name_top_length
For nicely formatted diagnostic output.
Definition Actor.h:344

RoR::Actor::ar_rescuer_flag
bool ar_rescuer_flag
Gameplay attr; defined in truckfile. TODO: Does anybody use this anymore?
Definition Actor.h:554

RoR::Actor::m_active_eventboxes
std::vector< std::pair< collision_box_t *, NodeNum_t > > m_active_eventboxes
Definition Actor.h:489

RoR::Actor::ar_main_camera_node_dir
NodeNum_t ar_main_camera_node_dir
Sim attr; ar_camera_node_dir[0] >= 0 ? ar_camera_node_dir[0] : 0.
Definition Actor.h:442

RoR::Actor::GetCameraDir
Ogre::Vector3 GetCameraDir()
Definition Actor.h:306

RoR::Actor::ar_node_to_node_connections
std::vector< std::vector< int > > ar_node_to_node_connections
Definition Actor.h:375

RoR::Actor::ar_num_cameras
int ar_num_cameras
Definition Actor.h:439

RoR::Actor::calculateAveragePosition
void calculateAveragePosition()
Definition Actor.cpp:1166

RoR::Actor::getFogLightsVisible
bool getFogLightsVisible() const
Definition Actor.h:222

RoR::Actor::ar_nb_shocks_d_interval
std::pair< float, float > ar_nb_shocks_d_interval
Search interval for springiness & damping of shock beams.
Definition Actor.h:542

RoR::Actor::getOrientation
Ogre::Quaternion getOrientation()
Definition Actor.cpp:375

RoR::Actor::ar_hooks
std::vector< hook_t > ar_hooks
Definition Actor.h:366

RoR::Actor::UpdateBoundingBoxes
void UpdateBoundingBoxes()
Definition Actor.cpp:1201

RoR::Actor::ar_collision_relevant
bool ar_collision_relevant
Physics state;.
Definition Actor.h:552

RoR::Actor::tractioncontrolToggle
void tractioncontrolToggle()
Definition Actor.cpp:3840

RoR::Actor::m_intra_point_col_detector
PointColDetector * m_intra_point_col_detector
Physics.
Definition Actor.h:620

RoR::Actor::ar_num_wheels
int ar_num_wheels
Definition Actor.h:385

RoR::Actor::setMass
void setMass(float m)
Definition Actor.cpp:4512

RoR::Actor::getNodeMass
float getNodeMass(int nodeNumber)
Definition Actor.cpp:4714

RoR::Actor::AddInterActorBeam
void AddInterActorBeam(beam_t *beam, ActorPtr other, ActorLinkingRequestType type)
Do not call directly - use MSG_SIM_ACTOR_LINKING_REQUESTED
Definition Actor.cpp:3364

RoR::Actor::UpdateCruiseControl
void UpdateCruiseControl(float dt)
Defined in 'gameplay/CruiseControl.cpp'.
Definition CruiseControl.cpp:48

RoR::Actor::m_used_skin_entry
CacheEntryPtr m_used_skin_entry
Optional, only graphics.
Definition Actor.h:669

RoR::Actor::m_previous_gear
int m_previous_gear
Sim state; land vehicle shifting.
Definition Actor.h:645

RoR::Actor::ar_nb_beams_k_interval
std::pair< float, float > ar_nb_beams_k_interval
Search interval for springiness & damping of regular beams.
Definition Actor.h:541

RoR::Actor::getScrewprop
ScrewpropPtr getScrewprop(int index)
Definition Actor.cpp:4658

RoR::Actor::m_rotation_request
float m_rotation_request
Accumulator.
Definition Actor.h:526

RoR::Actor::ar_shocks
shock_t * ar_shocks
Shock absorbers.
Definition Actor.h:355

RoR::Actor::CalcReplay
void CalcReplay()
Definition ActorForcesEuler.cpp:1161

RoR::Actor::m_net_first_wheel_node
int m_net_first_wheel_node
Network attr; Determines data buffer layout; calculated on spawn.
Definition Actor.h:680

RoR::Actor::m_camera_local_gforces_cur
Ogre::Vector3 m_camera_local_gforces_cur
Physics state (camera local)
Definition Actor.h:635

RoR::Actor::getUsedActorEntry
CacheEntryPtr & getUsedActorEntry()
The actor entry itself.
Definition Actor.cpp:4873

RoR::Actor::GetCameraRoll
Ogre::Vector3 GetCameraRoll()
Definition Actor.h:307

RoR::Actor::CalcForcesEulerPrepare
bool CalcForcesEulerPrepare(bool doUpdate)
Definition ActorForcesEuler.cpp:1169

RoR::Actor::tc_nodash
bool tc_nodash
Hide the dashboard indicator?
Definition Actor.h:507

RoR::Actor::ar_cinecam_node
NodeNum_t ar_cinecam_node[MAX_CAMERAS]
Sim attr; Cine-camera node indexes.
Definition Actor.h:433

RoR::Actor::ar_nodes_spawn_offsets
Ogre::Vector3 * ar_nodes_spawn_offsets
Relative positions (incl. Tuning system tweaks) from the definition file, for spawn-like resetting (i...
Definition Actor.h:335

RoR::Actor::alb_pulse_state
bool alb_pulse_state
Anti-lock brake state;.
Definition Actor.h:412

RoR::Actor::m_avg_node_position
Ogre::Vector3 m_avg_node_position
average node position
Definition Actor.h:622

RoR::Actor::getReverseLightVisible
bool getReverseLightVisible() const
Definition Actor.h:208

RoR::Actor::Intersects
bool Intersects(ActorPtr actor, Ogre::Vector3 offset=Ogre::Vector3::ZERO)
Slow intersection test.
Definition Actor.cpp:926

RoR::Actor::toggleCustomParticles
void toggleCustomParticles()
Definition Actor.cpp:3257

RoR::Actor::CalcNodes
void CalcNodes()
Definition ActorForcesEuler.cpp:1602

RoR::Actor::m_used_addonpart_entries
CacheEntryPtrVec m_used_addonpart_entries
Optional, assigned by player via Tuning menu (.tuneup files).
Definition Actor.h:670

RoR::Actor::m_hud_features_ok
bool m_hud_features_ok
Gfx state; Are HUD features matching actor's capabilities?
Definition Actor.h:696

RoR::Actor::ar_hydro_dir_wheel_display
Ogre::Real ar_hydro_dir_wheel_display
Definition Actor.h:458

RoR::Actor::m_avg_proped_wheel_radius
float m_avg_proped_wheel_radius
Physics attr, filled at spawn - Average proped wheel radius.
Definition Actor.h:617

RoR::Actor::m_net_node_buf_size
size_t m_net_node_buf_size
For incoming/outgoing traffic; calculated on spawn.
Definition Actor.h:675

RoR::Actor::getAirbrakeIntensity
float getAirbrakeIntensity()
Definition Actor.h:114

RoR::Actor::getTruckType
int getTruckType()
Definition Actor.h:269

RoR::Actor::softRespawn
void softRespawn(Ogre::Vector3 spawnpos, Ogre::Quaternion spawnrot)
Use MSG_SIM_MODIFY_ACTOR_REQUESTED with type SOFT_RESPAWN; Resets the actor to given position as if s...
Definition Actor.cpp:1376

RoR::Actor::setFogLightsVisible
void setFogLightsVisible(bool val)
Definition Actor.h:223

RoR::Actor::m_trigger_debug_enabled
bool m_trigger_debug_enabled
Logging state.
Definition Actor.h:705

RoR::Actor::ar_beams
beam_t * ar_beams
Definition Actor.h:348

RoR::Actor::DetermineLinkedActors
void DetermineLinkedActors()
Definition Actor.cpp:861

RoR::Actor::ar_trailer_parking_brake
bool ar_trailer_parking_brake
Definition Actor.h:468

RoR::Actor::reset
void reset(bool keep_position=false)
call this one to reset a truck from any context
Definition Actor.cpp:1622

RoR::Actor::ar_num_buoycabs
int ar_num_buoycabs
Definition Actor.h:402

RoR::Actor::m_force_sensors
struct RoR::Actor::VehicleForceSensors m_force_sensors
Data for ForceFeedback devices.

RoR::Actor::ar_toggle_ties
bool ar_toggle_ties
Sim state.
Definition Actor.h:558

RoR::Actor::m_used_assetpack_entries
CacheEntryPtrVec m_used_assetpack_entries
Optional, specified by mod author in truck file via 'assetpacks' section.
Definition Actor.h:671

RoR::Actor::m_reset_timer
Ogre::Timer m_reset_timer
Definition Actor.h:632

RoR::Actor::ar_collcabs
int ar_collcabs[MAX_CABS]
Definition Actor.h:396

RoR::Actor::setAircraftFlaps
void setAircraftFlaps(int flapsLevel)
Definition Actor.cpp:2988

RoR::Actor::getNodeInitialMass
float getNodeInitialMass(int nodeNumber)
Definition Actor.cpp:4702

RoR::Actor::getDryMass
float getDryMass()
Definition Actor.h:93

RoR::Actor::ar_nb_skip_steps
int ar_nb_skip_steps
Amount of physics steps to be skipped before measuring.
Definition Actor.h:534

RoR::Actor::ar_has_active_shocks
bool ar_has_active_shocks
Are there active stabilizer shocks?
Definition Actor.h:357

RoR::Actor::getUsedAssetpackEntries
CacheEntryPtrVec & getUsedAssetpackEntries()
Definition Actor.cpp:4888

RoR::Actor::CalcBeamsInterActor
void CalcBeamsInterActor()
Definition ActorForcesEuler.cpp:1469

RoR::Actor::ar_num_contactable_nodes
int ar_num_contactable_nodes
Total number of nodes which can contact ground or cabs.
Definition Actor.h:382

RoR::Actor::m_working_tuneup_def
TuneupDefPtr m_working_tuneup_def
Each actor gets unique instance, even if loaded from .tuneup file in modcache.
Definition Actor.h:666

RoR::Actor::ar_initial_node_masses
std::vector< float > ar_initial_node_masses
Definition Actor.h:339

RoR::Actor::resetPosition
void resetPosition(Ogre::Vector3 translation, bool setInitPosition)
Moves the actor to given world coords (pivot point is node 0).
Definition Actor.cpp:1351

RoR::Actor::getWorkingTuneupDef
TuneupDefPtr & getWorkingTuneupDef()
Definition Actor.cpp:4893

RoR::Actor::ar_guisettings_use_engine_max_rpm
bool ar_guisettings_use_engine_max_rpm
Definition Actor.h:513

RoR::Actor::m_potential_eventboxes
CollisionBoxPtrVec m_potential_eventboxes
Definition Actor.h:488

RoR::Actor::CalcWheels
void CalcWheels(bool doUpdate, int num_steps)
Definition ActorForcesEuler.cpp:332

RoR::Actor::getForcedCinecam
bool getForcedCinecam(CineCameraID_t &cinecam_id, BitMask_t &flags)
Definition Actor.cpp:5079

RoR::Actor::cc_target_speed
float cc_target_speed
Cruise Control.
Definition Actor.h:420

RoR::Actor::isLocked
bool isLocked()
Are hooks locked?
Definition Actor.cpp:3932

RoR::Actor::sl_speed_limit
float sl_speed_limit
Speed limiter;.
Definition Actor.h:424

RoR::Actor::ar_num_rotators
int ar_num_rotators
Definition Actor.h:359

RoR::Actor::m_avg_node_position_prev
Ogre::Vector3 m_avg_node_position_prev
Definition Actor.h:624

RoR::Actor::ar_driveable
ActorType ar_driveable
Sim attr; marks vehicle type and features.
Definition Actor.h:431

RoR::Actor::ar_net_stream_id
int ar_net_stream_id
Definition Actor.h:480

RoR::Actor::setLoadedMass
void setLoadedMass(float m)
Definition Actor.cpp:4517

RoR::Actor::setBeaconMode
void setBeaconMode(bool val)
Definition Actor.h:224

RoR::Actor::getGForces
Ogre::Vector3 getGForces()
Definition Actor.h:91

RoR::Actor::ar_main_camera_node_roll
NodeNum_t ar_main_camera_node_roll
Sim attr; ar_camera_node_roll[0] >= 0 ? ar_camera_node_roll[0] : 0.
Definition Actor.h:443

RoR::Actor::getTurboprop
AeroEnginePtr getTurboprop(int index)
Definition Actor.cpp:4645

RoR::Actor::cc_can_brake
bool cc_can_brake
Cruise Control.
Definition Actor.h:418

RoR::Actor::cruisecontrolToggle
void cruisecontrolToggle()
Defined in 'gameplay/CruiseControl.cpp'.
Definition CruiseControl.cpp:31

RoR::Actor::ar_unique_commandkey_pairs
std::vector< UniqueCommandKeyPair > ar_unique_commandkey_pairs
UI helper for displaying command control keys to user (must be built at spawn).
Definition Actor.h:380

RoR::Actor::getHeadlightsVisible
bool getHeadlightsVisible() const
Definition Actor.h:218

RoR::Actor::m_rotation_request_center
Ogre::Vector3 m_rotation_request_center
Definition Actor.h:525

RoR::ActorManager
Builds and manages softbody actors (physics on background thread, networking)
Definition ActorManager.h:45

RoR::ActorSpawner
Processes a RigDef::Document (parsed from 'truck' file format) into a simulated gameplay object (Acto...
Definition ActorSpawner.h:71

RoR::Airfoil
Represents an airfoil http://en.wikipedia.org/wiki/Airfoil.
Definition Airfoil.h:32

RoR::CmdKeyArray
For backwards compatibility of the 'triggers' feature, the commandkey array must support negative ind...
Definition SimData.h:632

RoR::Differential
Definition Differentials.h:66

RoR::GfxActor
Definition GfxActor.h:53

RoR::OutGauge
Definition OutGauge.h:46

RoR::PointColDetector
Definition PointColDetector.h:33

RoR::Replay
Definition Replay.h:40

RoR::Skidmark
Definition Skidmark.h:59

RoR::SlideNode
Definition SlideNode.h:65

RoR::TransferCase
Definition Differentials.h:43

RoR::TyrePressure
Land vehicle feat Simulates tyre pressurization by adjusting springness of in-wheel beams.
Definition TyrePressure.h:42

RoR::CollisionBoxPtrVec
std::vector< collision_box_t * > CollisionBoxPtrVec
Definition SimData.h:700

RoR::BlinkType
BlinkType
< Turn signal
Definition SimData.h:114

RoR::ActorType
ActorType
< Aka 'Driveable'
Definition SimData.h:81

RoR::EngineTriggerType
EngineTriggerType
Definition SimData.h:212

RoR::NOT_DRIVEABLE
@ NOT_DRIVEABLE
not drivable at all
Definition SimData.h:84

DEFAULT_COLLISION_RANGE
static const float DEFAULT_COLLISION_RANGE
Definition SimConstants.h:53

RoR::ActorState
ActorState
Definition SimData.h:239

RoR::ActorState::LOCAL_SIMULATED
@ LOCAL_SIMULATED
simulated (local) actor

RigDef::DocumentPtr
std::shared_ptr< Document > DocumentPtr
Definition ForwardDeclarations.h:293

RoR
Definition AppContext.h:36

RoR::NODENUM_INVALID
static const NodeNum_t NODENUM_INVALID
Definition ForwardDeclarations.h:55

RoR::ActorPtrVec
std::vector< ActorPtr > ActorPtrVec
Definition ForwardDeclarations.h:256

RoR::GfxFlaresMode
GfxFlaresMode
Definition Application.h:394

RoR::GfxFlaresMode::NONE
@ NONE
None (fastest)

RoR::ActorInstanceID_t
int ActorInstanceID_t
Unique sequentially generated ID of an actor in session. Use ActorManager::GetActorById()
Definition ForwardDeclarations.h:38

RoR::CineCameraID_t
int CineCameraID_t
Index into Actor::ar_cinecam_node and Actor::ar_camera_node_* arrays; use RoR::CINECAMERAID_INVALID a...
Definition ForwardDeclarations.h:79

RoR::ActorLinkingRequestType
ActorLinkingRequestType
Definition SimData.h:886

RoR::ActorLinkingRequestType::TIE_TOGGLE
@ TIE_TOGGLE

RoR::ActorLinkingRequestType::HOOK_TOGGLE
@ HOOK_TOGGLE

RoR::ActorLinkingRequestType::ROPE_TOGGLE
@ ROPE_TOGGLE

RoR::ActorSimAttr
ActorSimAttr
Parameter to Actor::setSimAttribute() and Actor::getSimAttribute(); allows advanced users to tweak ph...
Definition SimData.h:925

RoR::ACTORINSTANCEID_INVALID
static const ActorInstanceID_t ACTORINSTANCEID_INVALID
Definition ForwardDeclarations.h:39

RoR::CacheEntryPtrVec
std::vector< CacheEntryPtr > CacheEntryPtrVec
Definition ForwardDeclarations.h:258

RoR::CINECAMERAID_INVALID
static const CineCameraID_t CINECAMERAID_INVALID
Definition ForwardDeclarations.h:80

RoR::ExtCameraMode
ExtCameraMode
Definition Application.h:561

RoR::ExtCameraMode::CLASSIC
@ CLASSIC

RoR::BuoyCachedNodeID_t
int BuoyCachedNodeID_t
Definition ForwardDeclarations.h:96

RoR::NodeNum_t
uint16_t NodeNum_t
Node position within Actor::ar_nodes; use RoR::NODENUM_INVALID as empty value.
Definition ForwardDeclarations.h:54

RoR::FlareType
FlareType
Definition Application.h:510

RoRnet::LIGHTMASK_REVERSE
@ LIGHTMASK_REVERSE
reverse light on
Definition RoRnet.h:121

RoRnet::LIGHTMASK_BEACONS
@ LIGHTMASK_BEACONS
beacons on
Definition RoRnet.h:122

RoRnet::LIGHTMASK_BRAKES
@ LIGHTMASK_BRAKES
brake lights on
Definition RoRnet.h:120

RoRnet::LIGHTMASK_FOGLIGHTS
@ LIGHTMASK_FOGLIGHTS
Definition RoRnet.h:118

RoRnet::LIGHTMASK_HEADLIGHT
@ LIGHTMASK_HEADLIGHT
Definition RoRnet.h:116

RoRnet::LIGHTMASK_HIGHBEAMS
@ LIGHTMASK_HIGHBEAMS
Definition RoRnet.h:117

RoRnet::LIGHTMASK_SIDELIGHTS
@ LIGHTMASK_SIDELIGHTS
Definition RoRnet.h:119

RoR::Actor::NetUpdate
Definition Actor.h:726

RoR::Actor::NetUpdate::veh_state
std::vector< char > veh_state
Actor properties (engine, brakes, lights, ...)
Definition Actor.h:727

RoR::Actor::NetUpdate::node_data
std::vector< char > node_data
Compressed node positions.
Definition Actor.h:728

RoR::Actor::NetUpdate::wheel_data
std::vector< float > wheel_data
Wheel rotations.
Definition Actor.h:729

RoR::Actor::VehicleForceSensors
Definition Actor.h:710

RoR::Actor::VehicleForceSensors::out_body_forces
Ogre::Vector3 out_body_forces
Definition Actor.h:721

RoR::Actor::VehicleForceSensors::out_hydros_forces
float out_hydros_forces
Definition Actor.h:722

RoR::Actor::VehicleForceSensors::accu_body_forces
Ogre::Vector3 accu_body_forces
Definition Actor.h:719

RoR::Actor::VehicleForceSensors::Reset
void Reset()
Definition Actor.h:711

RoR::Actor::VehicleForceSensors::accu_hydros_forces
float accu_hydros_forces
Definition Actor.h:720

RoR::ActorSpawnRequest
Definition SimData.h:818

RoR::PerVehicleCameraContext
Definition PerVehicleCameraContext.h:14

RoR::beam_t
Simulation: An edge in the softbody structure.
Definition SimData.h:305

RoR::collcab_rate_t
Definition SimData.h:382

RoR::ground_model_t
Surface friction properties.
Definition SimData.h:704

RoR::hydrobeam_t
< beams updating length based on simulation variables, generally known as actuators.
Definition SimData.h:571

RoR::node_t
Physics: A vertex in the softbody structure.
Definition SimData.h:260

RoR::rotator_t
Definition SimData.h:582

RoR::shock_t
Definition SimData.h:344

RoR::soundsource_t
Definition SimData.h:390

RoR::wheel_t
Definition SimData.h:400

RoR::wing_t
Definition SimData.h:520