renderer: Fix lock of resource reads in render entity.

Author: heinezen

libopenage/renderer/stages/world/object.cpp

@@ -63,6 +63,9 @@ void WorldObject::fetch_updates(const time::time_t &time) {
 
 	// Get data from render entity
 	this->ref_id = this->render_entity->get_id();
+
+	// Thread-safe access to curves needs a lock on the render entity's mutex
+	auto read_lock = this->render_entity->get_read_lock();
 	this->position.sync(this->render_entity->get_position());
 	this->animation_info.sync(this->render_entity->get_animation_path(),
 	                          std::function<std::shared_ptr<renderer::resources::Animation2dInfo>(const std::string &)>(
@@ -79,6 +82,9 @@ void WorldObject::fetch_updates(const time::time_t &time) {
 	                          this->last_update);
 	this->angle.sync(this->render_entity->get_angle(), this->last_update);
 
+	// Unlock mutex of the render entity
+	read_lock.unlock();
+
 	// Set self to changed so that world renderer can update the renderable
 	this->changed = true;
 	this->render_entity->clear_changed_flag();

libopenage/renderer/stages/world/render_entity.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022-2023 the openage authors. See copying.md for legal info.
+// Copyright 2022-2024 the openage authors. See copying.md for legal info.
 
 #include "render_entity.h"
 
@@ -96,4 +96,8 @@ void WorldRenderEntity::clear_changed_flag() {
 	this->changed = false;
 }
 
+std::shared_lock<std::shared_mutex> WorldRenderEntity::get_read_lock() {
+	return std::shared_lock{this->mutex};
+}
+
 } // namespace openage::renderer::world

libopenage/renderer/stages/world/render_entity.h

@@ -4,6 +4,7 @@
 
 #include <cstdint>
 #include <list>
+#include <mutex>
 #include <shared_mutex>
 #include <string>
 
@@ -30,6 +31,8 @@ class WorldRenderEntity {
 	/**
 	 * Update the render entity with information from the gamestate.
 	 *
+	 * Updating the render entity with this method is thread-safe.
+	 *
 	 * @param ref_id Game entity ID.
 	 * @param position Position of the game entity inside the game world.
 	 * @param angle Angle of the game entity inside the game world.
@@ -47,6 +50,8 @@ class WorldRenderEntity {
 	 *
 	 * Update the render entity with information from the gamestate.
 	 *
+	 * Updating the render entity with this method is thread-safe.
+	 *
 	 * @param ref_id Game entity ID.
 	 * @param position Position of the game entity inside the game world.
 	 * @param animation_path Path to the animation definition.
@@ -60,34 +65,47 @@ class WorldRenderEntity {
 	/**
 	 * Get the ID of the corresponding game entity.
 	 *
+	 * Accessing the game entity ID is thread-safe.
+	 *
 	 * @return Game entity ID.
 	 */
 	uint32_t get_id();
 
 	/**
 	 * Get the position of the entity inside the game world.
 	 *
+	 * Accessing the position curve REQUIRES a read lock on the render entity
+	 * (using \p get_read_lock()) to ensure thread safety.
+	 *
 	 * @return Position curve of the entity.
 	 */
 	const curve::Continuous<coord::scene3> &get_position();
 
 	/**
 	 * Get the angle of the entity inside the game world.
 	 *
+	 * Accessing the angle curve REQUIRES a read lock on the render entity
+	 * (using \p get_read_lock()) to ensure thread safety.
+	 *
 	 * @return Angle curve of the entity.
 	 */
 	const curve::Segmented<coord::phys_angle_t> &get_angle();
 
 	/**
 	 * Get the animation definition path.
 	 *
+	 * Accessing the animation path curve requires a read lock on the render entity
+	 * (using \p get_read_lock()) to ensure thread safety.
+	 *
 	 * @return Path to the animation definition file.
 	 */
 	const curve::Discrete<std::string> &get_animation_path();
 
 	/**
 	 * Get the time of the last update.
 	 *
+	 * Accessing the update time is thread-safe.
+	 *
 	 * @return Time of last update.
 	 */
 	time::time_t get_update_time();
@@ -105,6 +123,15 @@ class WorldRenderEntity {
 	 */
 	void clear_changed_flag();
 
+	/**
+	 * Get a shared lock for thread-safe reading from the render entity.
+	 *
+	 * The caller is responsible for unlocking the mutex after reading.
+	 *
+	 * @return Lock for the render entity.
+	 */
+	std::shared_lock<std::shared_mutex> get_read_lock();
+
 private:
 	/**
 	 * Flag for determining if the render entity has been updated by the