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

    void              setIndexedSimAttribute(ActorSimAttr attr, float val, int index);

    float             getSimAttribute(ActorSimAttr attr);

    float             getIndexedSimAttribute(ActorSimAttr attr, int index);

    void              recalculateNodeMasses();

    void              setAirbrakeIntensity(float intensity);

    void              setAircraftFlaps(int flapsLevel);

    void              wakeUp();

    void              sendToSleep();

    // not exported to scripting:

    void              applyNodeBeamScales();

    void              searchBeamDefaults();

    void              updateInitPosition();

    void              propagateNodeBeamChangesToDef();

    bool              shouldSetSimAttribute(ActorSimAttr attr, float val, int index = -1);


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

    bool              getParkingBrake() { return ar_parking_brake; }

    bool              getTractionControl() { return tc_mode; }

    bool              getAntiLockBrake() { return alb_mode; }

    bool              getCruiseControl() { return cc_mode; }

    void              parkingbrakeToggle();

    void              tractioncontrolToggle();

    void              antilockbrakeToggle();

    void              cruisecontrolToggle();

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

    int               getCameraCount() { return ar_num_cameras; }

    int               getCameraPosNode(int camIndex) { return camIndex >= 0 && camIndex < ar_num_cameras ? ar_camera_node_pos[camIndex] : NODENUM_INVALID; }

    int               getCameraDirNode(int camIndex) { return camIndex >= 0 && camIndex < ar_num_cameras ? ar_camera_node_dir[camIndex] : NODENUM_INVALID; }

    int               getCameraRollNode(int camIndex) { return camIndex >= 0 && camIndex < ar_num_cameras ? ar_camera_node_roll[camIndex] : NODENUM_INVALID; }

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

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


    float             getEventValue(int eventID, bool pure = false, InputSourceType valueSource = InputSourceType::IST_ANY);

    bool              getEventBoolValue(int eventID);

    bool              getEventBoolValueBounce(int eventID, float time = 0.2f);

    void              clearEventSimulatedValues();

    bool              hasEventSimulatedValue(int eventID);

    float             getEventSimulatedValue(int eventID);

    void              setEventSimulatedValue(int eventID, float value);

    void              resetEventSimulatedValue(int eventID);


    // not exported to scripting:


    // Determines whether input event values for this actor must be read from

    // the simulated values map. This allows us to send simulated inputs to actors

    // other than the player actor, without it being affected by InputEngine

    // values.

    bool              ShouldAllowNonSimulatedInputs();

    bool              isEventAnalog(int eventID);

    bool              isEventDefined(int eventID);

    float             getEventBounceTime(int eventID);


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


    // Overrides the input event values from InputEngine with custom values

    // for this actor.

    // As soon as an event-value pair is added to this map, values from the

    // InputEngine are ignored.

    std::map<int, float> ar_actor_event_simulated_values;


    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;

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

    float             ar_guisettings_shifter_anim_time = 0.4f;

    std::string       ar_guisettings_tacho_material;

    std::string       ar_guisettings_speedo_material;

    std::string       ar_guisettings_help_material;


    // Dashboards

    bool                m_hud_features_ok = false;

    DashBoardManagerPtr ar_dashboard;


    // 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_active:1;

    bool ar_hydro_speed_coupling_enabled: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;

    bool ar_arcade_controls: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_slidenodes_locked:1;

    bool m_net_initialized:1;

    bool m_water_contact:1;

    bool m_water_contact_old:1;

    bool m_has_command_beams:1;

    bool m_preloaded_with_terrain:1;

    bool m_beam_break_debug_enabled:1;

    bool m_beam_deform_debug_enabled:1;

    bool m_trigger_debug_enabled:1;

    bool m_disable_default_sounds:1;

    bool m_disable_smoke:1;


    struct VehicleForceSensors

    {


        inline void Reset()

        {

            accu_body_forces    = Ogre::Vector3::ZERO;

            accu_hydros_forces  = 0;

            out_body_forces     = Ogre::Vector3::ZERO;

            out_hydros_forces   = 0;

        };


        Ogre::Vector3 accu_body_forces;

        float         accu_hydros_forces;

        Ogre::Vector3 out_body_forces;

        float         out_hydros_forces;

    } m_force_sensors;


    struct NetUpdate

    {

        std::vector<char> veh_state;

        std::vector<char> node_data;

        std::vector<float> wheel_data;

    };


    std::deque<NetUpdate> m_net_updates;

};


} // namespace RoR

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_parking_brake
bool ar_parking_brake
Definition Actor.h:509

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:445

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

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:594

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

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

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

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

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

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

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

RoR::Actor::getCameraDirNode
int getCameraDirNode(int camIndex)
Definition Actor.h:184

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

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

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:592

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

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

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

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:584

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

RoR::Actor::shouldSetSimAttribute
bool shouldSetSimAttribute(ActorSimAttr attr, float val, int index=-1)
Definition Actor.cpp:5109

RoR::Actor::isEventDefined
bool isEventDefined(int eventID)
Definition Actor.cpp:3119

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

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:597

RoR::Actor::getEventBoolValueBounce
bool getEventBoolValueBounce(int eventID, float time=0.2f)
Definition Actor.cpp:3034

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

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

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:526

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:707

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

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

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

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

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

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:355

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:523

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

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:744

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

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

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

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

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

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

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

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

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

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

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:480

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:681

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:495

RoR::Actor::hasEventSimulatedValue
bool hasEventSimulatedValue(int eventID)
Definition Actor.cpp:3053

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

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

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

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

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:5035

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

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

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:585

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

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:386

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

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

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

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

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

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

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

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

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

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:3813

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

RoR::Actor::ar_dashboard
DashBoardManagerPtr ar_dashboard
Gfx state; Dashboard manager (HUD element manager)
Definition Actor.h:563

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

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

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

RoR::Actor::clearEventSimulatedValues
void clearEventSimulatedValues()
Definition Actor.cpp:3048

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

RoR::Actor::getCameraRollNode
int getCameraRollNode(int camIndex)
Definition Actor.h:185

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:3159

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

RoR::Actor::getEventBoolValue
bool getEventBoolValue(int eventID)
Definition Actor.cpp:3029

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:482

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

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

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:546

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

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

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

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:205

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

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

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:516

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

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:358

RoR::Actor::ar_hydro_speed_coupling_enabled
bool ar_hydro_speed_coupling_enabled
Should we use hydro coupling? This gets updated for the player actor according to 'io_hydro_coupling'...
Definition Actor.h:601

RoR::Actor::resetEventSimulatedValue
void resetEventSimulatedValue(int eventID)
Definition Actor.cpp:3089

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

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

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

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

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:4916

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

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

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

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

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

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

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

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:387

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

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

RoR::Actor::getCameraPosNode
int getCameraPosNode(int camIndex)
Definition Actor.h:183

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

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:667

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

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

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

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

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

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

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

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

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

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

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

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

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

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:588

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

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

RoR::Actor::sendToSleep
void sendToSleep()
Definition Actor.cpp:3007

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

RoR::Actor::getEventBounceTime
float getEventBounceTime(int eventID)
Definition Actor.cpp:3124

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

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:356

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

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

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

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

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:537

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

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

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

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:662

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

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

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:3383

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

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

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

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

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:754

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:385

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:481

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

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

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

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

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

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

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

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

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

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

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

RoR::Actor::setIndexedSimAttribute
void setIndexedSimAttribute(ActorSimAttr attr, float val, int index)
Definition Actor.cpp:5186

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:476

RoR::Actor::getTractionControl
bool getTractionControl()
Definition Actor.h:168

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

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:603

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

RoR::Actor::getCameraCount
int getCameraCount()
Definition Actor.h:182

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

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:755

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

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

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

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

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

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

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

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

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

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

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

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

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:607

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

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

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

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:581

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

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

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

RoR::Actor::ar_elevator
float ar_elevator
Sim state; aircraft elevator.
Definition Actor.h:513

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:412

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:735

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

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

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

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:375

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

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:593

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:521

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:598

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

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

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

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:589

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

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

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

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

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

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

RoR::Actor::getAntiLockBrake
bool getAntiLockBrake()
Definition Actor.h:169

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

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

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:254

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

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

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

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

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

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

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:357

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

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

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

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

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

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

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

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

RoR::Actor::getCruiseControl
bool getCruiseControl()
Definition Actor.h:170

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

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

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

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

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:5132

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

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

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:697

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

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

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

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

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

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

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

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

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

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

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:471

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

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

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

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::getEventValue
float getEventValue(int eventID, bool pure=false, InputSourceType valueSource=InputSourceType::IST_ANY)
Definition Actor.cpp:3015

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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:4842

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

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

RoR::Actor::ar_actor_event_simulated_values
std::map< int, float > ar_actor_event_simulated_values
Definition Actor.h:491

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

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

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

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

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

RoR::Actor::wakeUp
void wakeUp()
Definition Actor.cpp:2998

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:443

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

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

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

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

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:384

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

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

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:397

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

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

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

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

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

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

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

RoR::Actor::isEventAnalog
bool isEventAnalog(int eventID)
Definition Actor.cpp:3109

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

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

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

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

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

RoR::Actor::ar_rudder
float ar_rudder
Sim state; aircraft rudder (boat rudders are controlled in RoR::Screwprop)
Definition Actor.h:514

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:568

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

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

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:283

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

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

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

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

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

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

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

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

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

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

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

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

RoR::Actor::ShouldAllowNonSimulatedInputs
bool ShouldAllowNonSimulatedInputs()
Definition Actor.cpp:3098

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

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::setEventSimulatedValue
void setEventSimulatedValue(int eventID, float value)
Definition Actor.cpp:3073

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:479

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

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

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

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

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

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

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

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

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

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

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

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

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:4928

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

RoR::Actor::getEventSimulatedValue
float getEventSimulatedValue(int eventID)
Definition Actor.cpp:3061

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

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:440

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

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

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

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

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

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

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

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

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

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

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

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:706

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

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

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

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

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

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:475

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

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

RoR::Actor::ar_guisettings_speedo_material
std::string ar_guisettings_speedo_material
Used on 'renderdash'.
Definition Actor.h:558

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

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

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

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:540

RoR::Actor::ar_guisettings_tacho_material
std::string ar_guisettings_tacho_material
Used on 'renderdash'.
Definition Actor.h:557

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

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

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

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

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

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

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

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:442

RoR::Actor::ar_guisettings_help_material
std::string ar_guisettings_help_material
Used on 'renderdash'.
Definition Actor.h:559

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:305

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

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

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

RoR::Actor::ar_aileron
float ar_aileron
Sim state; aircraft aileron.
Definition Actor.h:515

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

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:470

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

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

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

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

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

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

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

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:418

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

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

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

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

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:477

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

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

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

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

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

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:591

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

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

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

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

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

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

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

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

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

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:3500

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:720

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

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:590

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

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

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

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:732

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

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

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

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:548

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

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:370

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

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

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

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:3393

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:721

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

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

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:668

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

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

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

RoR::Actor::ar_hydro_speed_coupling_active
bool ar_hydro_speed_coupling_active
Definition Actor.h:600

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:258

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

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

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

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

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:437

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:608

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:722

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

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

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

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

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:583

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

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

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:417

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:717

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

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:5045

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

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

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:5293

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

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

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

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

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

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

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

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

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

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:478

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

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

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

RoR::Actor::getIndexedSimAttribute
float getIndexedSimAttribute(ActorSimAttr attr, int index)
Definition Actor.cpp:5259

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:415

RoR::Actor::ar_arcade_controls
bool ar_arcade_controls
Should we use arcade controls? This gets updated for the player actor according to 'io_arcade_control...
Definition Actor.h:610

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

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

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:72

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

RoR::InputSourceType
InputSourceType
Definition InputEngine.h:67

RoR::InputSourceType::IST_ANY
@ IST_ANY

DEFAULT_COLLISION_RANGE
static const float DEFAULT_COLLISION_RANGE
Definition SimConstants.h:53

DEFAULT_SPEEDO_MAX_KPH
static const float DEFAULT_SPEEDO_MAX_KPH
Definition SimConstants.h:81

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:295

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:258

RoR::GfxFlaresMode
GfxFlaresMode
Definition Application.h:397

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::setIndexedSimAttribute() (and their get counterparts...
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:260

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

RoR::ExtCameraMode
ExtCameraMode
Definition Application.h:565

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:514

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:778

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

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

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

RoR::Actor::VehicleForceSensors
Definition Actor.h:762

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

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

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

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

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

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