🚧 Terrain editor: visually moving preloaded actors works.

Rotating still TBD.

To do this, 2 new 'types' had to be added to `MSG_SIM_MODIFY_ACTOR_REQUESTED`:
* SOFT_RESPAWN, //!< Like hard reset, but positions the actor like spawn process does - using the relative positions from rig-def file (respecting Tuning system tweaks).
* REFRESH_VISUALS //!< Forces a synchronous update of visuals from any context - i.e. from terrain editor mode or with sleeping/physicspaused actor.

Time spent: 90min

Author: ohlidalp

source/main/GameContext.cpp

@@ -415,6 +415,15 @@ void GameContext::ModifyActor(ActorModifyRequest& rq)
         // Load our actor again, but only after all actors are deleted.
         this->ChainMessage(Message(MSG_SIM_SPAWN_ACTOR_REQUESTED, (void*)srq));
     }
+    else if (rq.amr_type == ActorModifyRequest::Type::SOFT_RESPAWN)
+    {
+        actor->softRespawn(rq.amr_softrespawn_pos);
+    }
+    else if (rq.amr_type == ActorModifyRequest::Type::REFRESH_VISUALS)
+    {
+        actor->GetGfxActor()->UpdateSimDataBuffer();
+        App::GetGfxScene()->ForceUpdateSingleGfxActor(actor->GetGfxActor());
+    }
 }
 
 void GameContext::DeleteActor(ActorPtr actor)

source/main/gfx/GfxScene.cpp

@@ -329,6 +329,27 @@ void GfxScene::RemoveGfxActor(RoR::GfxActor* remove_me)
     }
 }
 
+void GfxScene::ForceUpdateSingleGfxActor(RoR::GfxActor* gfx_actor)
+{
+    // Do the work `UpdateScene()` would, but for a single actor.
+    // Needed for i.e. terrain editor mode.
+    // ------------------------------------------------------
+
+    // Start threaded stuff
+    gfx_actor->UpdateFlexbodies(); // Push flexbody tasks to threadpool
+    gfx_actor->UpdateWheelVisuals(); // Push flexwheel tasks to threadpool
+
+    // Do sync stuff
+    gfx_actor->UpdateRods();
+    gfx_actor->UpdateCabMesh();
+    gfx_actor->UpdateWingMeshes();
+    gfx_actor->UpdateAirbrakes();
+
+    // Finish threaded stuff
+    gfx_actor->FinishWheelUpdates();
+    gfx_actor->FinishFlexbodyTasks();
+}
+
 void GfxScene::RegisterGfxCharacter(RoR::GfxCharacter* gfx_character)
 {
     m_all_gfx_characters.push_back(gfx_character);

source/main/gfx/GfxScene.h

@@ -59,6 +59,7 @@ class GfxScene
     void           ClearScene();
     void           RegisterGfxActor(RoR::GfxActor* gfx_actor);
     void           RemoveGfxActor(RoR::GfxActor* gfx_actor);
+    void           ForceUpdateSingleGfxActor(RoR::GfxActor* gfx_actor);
     void           RegisterGfxCharacter(RoR::GfxCharacter* gfx_character);
     void           RemoveGfxCharacter(RoR::GfxCharacter* gfx_character);
     void           BufferSimulationData(); //!< Run this when simulation is halted

source/main/physics/Actor.cpp

@@ -1289,6 +1289,22 @@ void Actor::resetPosition(Ogre::Vector3 translation, bool setInitPosition)
     calculateAveragePosition();
 }
 
+void Actor::softRespawn(Ogre::Vector3 spawnpos)
+{
+    // Perform a hard reset (detach any linked actors etc...)
+    this->SyncReset(/*reset_position:*/ false);
+
+    // Move the actor to position
+    ar_origin = spawnpos;
+    for (NodeNum_t i = 0; i < ar_num_nodes; i++)
+    {
+        ar_nodes[i].AbsPosition = spawnpos + ar_nodes_spawn_offsets[i];
+        ar_nodes[i].RelPosition = ar_nodes_spawn_offsets[i];
+        ar_nodes[i].Forces = Ogre::Vector3::ZERO;
+        ar_nodes[i].Velocity = Ogre::Vector3::ZERO;
+    }
+}
+
 void Actor::mouseMove(NodeNum_t node, Vector3 pos, float force)
 {
     m_mouse_grab_node = node;

source/main/physics/Actor.h

@@ -98,8 +98,9 @@ class Actor : public RefCountingObject<Actor>
     int               getShockNode1(int shock_number);
     int               getShockNode2(int shock_number);
     // not exported to scripting:
-    void              resetPosition(Ogre::Vector3 translation, bool setInitPosition); //!< Moves the actor to given world coords.
-    void              resetPosition(float px, float pz, bool setInitPosition, float miny); //!< Moves the actor to given world coords.
+    void              resetPosition(Ogre::Vector3 translation, bool setInitPosition); //!< Moves the actor to given world coords (pivot point is node 0).
+    void              resetPosition(float px, float pz, bool setInitPosition, float miny); //!< Moves the actor to given world coords (pivot point is node 0).
+    void              softRespawn(Ogre::Vector3 spawnpos); //!< Use `MSG_SIM_MODIFY_ACTOR_REQUESTED` with type `SOFT_RESPAWN`; Resets the actor to given position as if spawned there (pivot point is `spawnpos`).
     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; };
@@ -281,6 +282,7 @@ class Actor : public RefCountingObject<Actor>
     int*                 ar_nodes_id = nullptr;                  //!< Number in truck file, -1 for nodes generated by wheels/cinecam
     std::string*         ar_nodes_name = nullptr;                //!< Name in truck file, only if defined with 'nodes2'
     int                  ar_nodes_name_top_length = 0; //!< For nicely formatted diagnostic output
+    Ogre::Vector3*       ar_nodes_spawn_offsets = nullptr; //!< Relative positions (incl. Tuning system tweaks) from the definition file, for spawn-like resetting (i.e. with terrain editor on preloaded actor).
     int                  ar_num_nodes = 0;
     std::vector<float>   ar_minimass;                  //!< minimum node mass in Kg
     bool                 ar_minimass_skip_loaded_nodes = false;
@@ -308,7 +310,7 @@ class Actor : public RefCountingObject<Actor>
     Ogre::AxisAlignedBox      ar_predicted_bounding_box;
     float                     ar_initial_total_mass = 0.f;
     std::vector<float>        ar_initial_node_masses;
-    std::vector<Ogre::Vector3>     ar_initial_node_positions;
+    std::vector<Ogre::Vector3>     ar_initial_node_positions; //!< Absolute world positions, for resetting to pristine state.
     std::vector<std::pair<float, float>> ar_initial_beam_defaults;
     std::vector<wheeldetacher_t>   ar_wheeldetachers;
     std::vector<std::vector<int>>  ar_node_to_node_connections;

source/main/physics/ActorSpawner.cpp

@@ -266,6 +266,7 @@ void ActorSpawner::InitializeRig()
         m_actor->ar_nodes_id[i] = -1;
     }
     m_actor->ar_nodes_name = new std::string[req.num_nodes];
+    m_actor->ar_nodes_spawn_offsets = new Ogre::Vector3[req.num_nodes];
 
     if (req.num_shocks > 0)
         m_actor->ar_shocks = new shock_t[req.num_shocks];
@@ -4743,6 +4744,7 @@ void ActorSpawner::BuildWheelObjectAndNodes(
     {
         /* Outer ring */
         Ogre::Vector3 ray_point = axis_node_1->RelPosition + ray_vector;
+        Ogre::Vector3 ray_spawnpoint = m_actor->ar_nodes_spawn_offsets[axis_node_1->pos] + ray_vector;
         ray_vector = ray_rotator * ray_vector;
 
         node_t & outer_node = GetFreeNode();
@@ -4753,9 +4755,11 @@ void ActorSpawner::BuildWheelObjectAndNodes(
         AdjustNodeBuoyancy(outer_node, node_defaults);
 
         m_actor->m_gfx_actor->m_gfx_nodes.push_back(NodeGfx(outer_node.pos));
+        m_actor->ar_nodes_spawn_offsets[outer_node.pos] = ray_spawnpoint;
 
         /* Inner ring */
         ray_point = axis_node_2->RelPosition + ray_vector;
+        ray_spawnpoint = m_actor->ar_nodes_spawn_offsets[axis_node_2->pos] + ray_vector;
         ray_vector = ray_rotator * ray_vector;
 
         node_t & inner_node = GetFreeNode();
@@ -4766,6 +4770,7 @@ void ActorSpawner::BuildWheelObjectAndNodes(
         AdjustNodeBuoyancy(inner_node, node_defaults);
 
         m_actor->m_gfx_actor->m_gfx_nodes.push_back(NodeGfx(inner_node.pos));
+        m_actor->ar_nodes_spawn_offsets[inner_node.pos] = ray_spawnpoint;
 
         /* Wheel object */
         wheel.wh_nodes[i * 2] = & outer_node;
@@ -5927,7 +5932,10 @@ void ActorSpawner::ProcessNode(RigDef::Node & def)
     node.pos = inserted_node.first; /* Node index */
 
     /* Positioning */
-    Ogre::Vector3 node_position = m_spawn_position + TuneupUtil::getTweakedNodePosition(m_actor->getWorkingTuneupDef(), node.pos, def.position);
+    const Ogre::Vector3 spawn_offset = TuneupUtil::getTweakedNodePosition(m_actor->getWorkingTuneupDef(), node.pos, def.position);
+    m_actor->ar_nodes_spawn_offsets[inserted_node.first] = spawn_offset;
+
+    Ogre::Vector3 node_position = m_spawn_position + spawn_offset;
     ROR_ASSERT(!std::isnan(node_position.x));
     ROR_ASSERT(!std::isnan(node_position.y));
     ROR_ASSERT(!std::isnan(node_position.z));
@@ -6080,6 +6088,7 @@ void ActorSpawner::ProcessCinecam(RigDef::Cinecam & def)
     // Node
     Ogre::Vector3 node_pos = m_spawn_position + def.position;
     node_t & camera_node = GetAndInitFreeNode(node_pos);
+    m_actor->ar_nodes_spawn_offsets[camera_node.pos] = def.position;
     camera_node.nd_no_ground_contact = true; // Orig: hardcoded in BTS_CINECAM
     camera_node.friction_coef = NODE_FRICTION_COEF_DEFAULT; // Node defaults are ignored here.
     AdjustNodeBuoyancy(camera_node, def.node_defaults);

source/main/physics/SimData.h

@@ -860,9 +860,11 @@ struct ActorModifyRequest
         RELOAD,               //!< Full reload from filesystem, requested by user
         RESET_ON_INIT_POS,
         RESET_ON_SPOT,
+        SOFT_RESPAWN, //!< Like hard reset, but positions the actor like spawn process does - using the relative positions from rig-def file (respecting Tuning system tweaks).
         SOFT_RESET,
         RESTORE_SAVED,
         WAKE_UP,
+        REFRESH_VISUALS //!< Forces a synchronous update of visuals from any context - i.e. from terrain editor mode or with sleeping/physicspaused actor.
     };
 
     ActorInstanceID_t   amr_actor = ACTORINSTANCEID_INVALID;// not ActorPtr because it's not thread-safe
@@ -871,6 +873,7 @@ struct ActorModifyRequest
                         amr_saved_state;
     CacheEntryPtr       amr_addonpart; //!< Primary method of specifying cache entry.
     std::string         amr_addonpart_fname; //!< Fallback method in case CacheEntry doesn't exist anymore - that means mod was uninstalled in the meantime. Used by REMOVE_ADDONPART_AND_RELOAD.
+    Ogre::Vector3       amr_softrespawn_pos; //!< Position to use with `SOFT_RESPAWN`.
 };
 
 enum class ActorLinkingRequestType

source/main/terrain/TerrainEditor.cpp

@@ -395,9 +395,17 @@ void TerrainEditorObject::setPosition(Ogre::Vector3 const& pos)
             actor->requestTranslation(pos - actor->getPosition());
 
             ActorModifyRequest* req = new ActorModifyRequest();
-            req->amr_type = ActorModifyRequest::Type::RESET_ON_SPOT;
+            req->amr_type = ActorModifyRequest::Type::SOFT_RESPAWN;
             req->amr_actor = actor->ar_instance_id;
+            req->amr_softrespawn_pos = pos;
             App::GetGameContext()->PushMessage(Message(MSG_SIM_MODIFY_ACTOR_REQUESTED, (void*)req));
+            req = nullptr;
+
+            ActorModifyRequest* fxreq = new ActorModifyRequest();
+            fxreq->amr_type = ActorModifyRequest::Type::REFRESH_VISUALS;
+            fxreq->amr_actor = actor->ar_instance_id;
+            App::GetGameContext()->PushMessage(Message(MSG_SIM_MODIFY_ACTOR_REQUESTED, (void*)fxreq));
+            fxreq = nullptr;
         }
     }
 }