Add dirty flag and integrate

libopenage/pathfinding/CMakeLists.txt

@@ -1,6 +1,7 @@
 add_sources(libopenage
     cost_field.cpp
 	definitions.cpp
+	field_cache.cpp
     flow_field.cpp
 	grid.cpp
 	integration_field.cpp

libopenage/pathfinding/cost_field.cpp

@@ -13,7 +13,8 @@ namespace openage::path {
 
 CostField::CostField(size_t size) :
 	size{size},
-	cells(this->size * this->size, COST_MIN) {
+	cells(this->size * this->size, COST_MIN),
+	changed{time::time_t::min_value()} {
 	log::log(DBG << "Created cost field with size " << this->size << "x" << this->size);
 }
 
@@ -33,29 +34,42 @@ cost_t CostField::get_cost(size_t idx) const {
 	return this->cells.at(idx);
 }
 
-void CostField::set_cost(const coord::tile_delta &pos, cost_t cost) {
+void CostField::set_cost(const coord::tile_delta &pos, cost_t cost, time::time_t &changed) {
 	this->cells[pos.ne + pos.se * this->size] = cost;
+	this->changed = changed;
 }
 
-void CostField::set_cost(size_t x, size_t y, cost_t cost) {
+void CostField::set_cost(size_t x, size_t y, cost_t cost, time::time_t &changed) {
 	this->cells[x + y * this->size] = cost;
+	this->changed = changed;
 }
 
 void CostField::set_cost(size_t idx, cost_t cost) {
 	this->cells[idx] = cost;
+	this->changed = time::TIME_ZERO;
+}
+
+void CostField::set_cost(size_t idx, cost_t cost,time::time_t &changed) {
+	this->cells[idx] = cost;
+	this->changed = changed;
 }
 
 const std::vector<cost_t> &CostField::get_costs() const {
 	return this->cells;
 }
 
-void CostField::set_costs(std::vector<cost_t> &&cells) {
+void CostField::set_costs(std::vector<cost_t> &&cells, time::time_t &changed) {
 	ENSURE(cells.size() == this->cells.size(),
 	       "cells vector has wrong size: " << cells.size()
 	                                       << "; expected: "
 	                                       << this->cells.size());
 
 	this->cells = std::move(cells);
+	this->changed = changed;
+}
+
+bool CostField::is_dirty(time::time_t &time) {
+	return time <= this->changed;
 }
 
 } // namespace openage::path

libopenage/pathfinding/cost_field.h

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "pathfinding/types.h"
+#include "time/time.h"
 
 
 namespace openage {
@@ -64,17 +65,19 @@ class CostField {
 	 *
 	 * @param pos Coordinates of the cell (relative to field origin).
 	 * @param cost Cost to set.
+	 * @param changed Time cost is set.
 	 */
-	void set_cost(const coord::tile_delta &pos, cost_t cost);
+	void set_cost(const coord::tile_delta &pos, cost_t cost, time::time_t &changed);
 
 	/**
 	 * Set the cost at a specified position.
 	 *
 	 * @param x X-coordinate of the cell.
 	 * @param y Y-coordinate of the cell.
 	 * @param cost Cost to set.
+	 * @param changed Time cost is set.
 	 */
-	void set_cost(size_t x, size_t y, cost_t cost);
+	void set_cost(size_t x, size_t y, cost_t cost, time::time_t &changed);
 
 	/**
 	 * Set the cost at a specified position.
@@ -84,6 +87,15 @@ class CostField {
 	 */
 	void set_cost(size_t idx, cost_t cost);
 
+	/**
+	 * Set the cost at a specified position.
+	 *
+	 * @param idx Index of the cell.
+	 * @param cost Cost to set.
+	 * @param changed Time cost is set.
+	 */
+	void set_cost(size_t idx, cost_t cost, time::time_t &changed);
+
 	/**
 	 * Get the cost field values.
 	 *
@@ -95,15 +107,25 @@ class CostField {
 	 * Set the cost field values.
 	 *
 	 * @param cells Cost field values.
+	 * @param changed Time cost is set.
 	 */
-	void set_costs(std::vector<cost_t> &&cells);
+	void set_costs(std::vector<cost_t> &&cells, time::time_t &changed);
+
+	/**
+	 * Check if the cost field is dirty at the specified time.
+	 * 
+	 * @param time Specified time to check.
+	 */
+	bool is_dirty(time::time_t &time);
 
 private:
 	/**
 	 * Side length of the field.
 	 */
 	size_t size;
 
+	time::time_t changed;
+
 	/**
 	 * Cost field values.
 	 */

libopenage/pathfinding/demo/demo_0.cpp

@@ -33,15 +33,17 @@ void path_demo_0(const util::Path &path) {
 
 	// Cost field with some obstacles
 	auto cost_field = std::make_shared<CostField>(field_length);
-	cost_field->set_cost(coord::tile_delta{0, 0}, COST_IMPASSABLE);
-	cost_field->set_cost(coord::tile_delta{1, 0}, 254);
-	cost_field->set_cost(coord::tile_delta{4, 3}, 128);
-	cost_field->set_cost(coord::tile_delta{5, 3}, 128);
-	cost_field->set_cost(coord::tile_delta{6, 3}, 128);
-	cost_field->set_cost(coord::tile_delta{4, 4}, 128);
-	cost_field->set_cost(coord::tile_delta{5, 4}, 128);
-	cost_field->set_cost(coord::tile_delta{6, 4}, 128);
-	cost_field->set_cost(coord::tile_delta{1, 7}, COST_IMPASSABLE);
+
+	time::time_t time = time::TIME_ZERO;
+	cost_field->set_cost(coord::tile_delta{0, 0}, COST_IMPASSABLE, time);
+	cost_field->set_cost(coord::tile_delta{1, 0}, 254, time);
+	cost_field->set_cost(coord::tile_delta{4, 3}, 128, time);
+	cost_field->set_cost(coord::tile_delta{5, 3}, 128, time);
+	cost_field->set_cost(coord::tile_delta{6, 3}, 128, time);
+	cost_field->set_cost(coord::tile_delta{4, 4}, 128, time);
+	cost_field->set_cost(coord::tile_delta{5, 4}, 128, time);
+	cost_field->set_cost(coord::tile_delta{6, 4}, 128, time);
+	cost_field->set_cost(coord::tile_delta{1, 7}, COST_IMPASSABLE, time);
 	log::log(INFO << "Created cost field");
 
 	// Create an integration field from the cost field

libopenage/pathfinding/demo/demo_1.cpp

@@ -11,6 +11,8 @@
 #include "pathfinding/portal.h"
 #include "pathfinding/sector.h"
 #include "util/timer.h"
+#include "time/time_loop.h"
+#include "time/clock.h"
 
 #include "renderer/gui/integration/public/gui_application_with_logger.h"
 #include "renderer/opengl/window.h"
@@ -25,13 +27,17 @@
 namespace openage::path::tests {
 
 void path_demo_1(const util::Path &path) {
+	auto time_loop = std::make_shared<time::TimeLoop>();
+	time_loop->run();
+	auto clock = time_loop->get_clock();
 	auto grid = std::make_shared<Grid>(0, util::Vector2s{4, 3}, 10);
 
+	time::time_t time = clock->get_time();
 	// Initialize the cost field for each sector.
 	for (auto &sector : grid->get_sectors()) {
 		auto cost_field = sector->get_cost_field();
 		std::vector<cost_t> sector_cost = sectors_cost.at(sector->get_id());
-		cost_field->set_costs(std::move(sector_cost));
+		cost_field->set_costs(std::move(sector_cost), time);
 	}
 
 	// Initialize portals between sectors.
@@ -87,16 +93,20 @@ void path_demo_1(const util::Path &path) {
 	coord::tile start{2, 26};
 	coord::tile target{36, 2};
 
+	time::time_t request_time = clock->get_time();
+
 	PathRequest path_request{
 		grid->get_id(),
 		start,
 		target,
+		request_time
 	};
+
+	log::log(INFO << "Pathfinding request at " << request_time);
 	grid->init_portal_nodes();
 	timer.start();
 	Path path_result = pathfinder->get_path(path_request);
 	timer.stop();
-
 	log::log(INFO << "Pathfinding took " << timer.getval() / 1000 << " us");
 
 	// Create a renderer to display the grid and path
@@ -127,6 +137,7 @@ void path_demo_1(const util::Path &path) {
 					grid->get_id(),
 					start,
 					target,
+					clock->get_time()
 				};
 
 				timer.reset();
@@ -147,6 +158,7 @@ void path_demo_1(const util::Path &path) {
 					grid->get_id(),
 					start,
 					target,
+					clock->get_time()
 				};
 
 				timer.reset();

libopenage/pathfinding/field_cache.cpp

@@ -0,0 +1,32 @@
+// Copyright 2024-2024 the openage authors. See copying.md for legal info.
+
+#include "field_cache.h"
+
+namespace openage::path {
+
+void FieldCache::add(std::pair<unsigned long long, unsigned long long> cache_key,
+            std::shared_ptr<IntegrationField> &integration_field,
+            std::shared_ptr<FlowField> &flow_field) {
+    this->cache[cache_key] = std::make_pair(integration_field, flow_field);
+}
+
+void FieldCache::evict(std::pair<unsigned long long, unsigned long long> cache_key) {
+    this->cache.erase(cache_key);
+}
+
+bool FieldCache::is_cached(std::pair<unsigned long long, unsigned long long> cache_key) {
+    auto cached = this->cache.find(cache_key);
+    return cached != this->cache.end();
+}
+
+std::shared_ptr<IntegrationField> FieldCache::get_integration_field(std::pair<unsigned long long, unsigned long long> cache_key) {
+    auto cached = this->cache.find(cache_key);
+    return cached->second.first;
+}
+
+std::shared_ptr<FlowField> FieldCache::get_flow_field(std::pair<unsigned long long, unsigned long long> cache_key) {
+    auto cached = this->cache.find(cache_key);
+    return cached->second.second;
+}
+
+} // namespace openage::path

libopenage/pathfinding/field_cache.h

@@ -0,0 +1,66 @@
+// Copyright 2024-2024 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+
+#include "pathfinding/types.h"
+#include "util/hash.h"
+
+namespace openage {
+namespace coord {
+struct tile_delta;
+} // namespace coord
+
+namespace path {
+class IntegrationField;
+class FlowField;
+
+class FieldCache
+{
+public:
+    FieldCache() = default;
+    ~FieldCache() = default;
+
+    void add(std::pair<unsigned long long, unsigned long long> cache_key,
+             std::shared_ptr<IntegrationField> &integration_field,
+             std::shared_ptr<FlowField> &flow_field);
+
+	void evict(std::pair<unsigned long long, unsigned long long> cache_key);
+
+    bool is_cached(std::pair<unsigned long long, unsigned long long> cache_key);
+
+    std::shared_ptr<IntegrationField> get_integration_field(std::pair<unsigned long long, unsigned long long> cache_key);
+
+    std::shared_ptr<FlowField> get_flow_field(std::pair<unsigned long long, unsigned long long> cache_key);
+
+    using get_return_t = std::pair<std::shared_ptr<IntegrationField>, std::shared_ptr<FlowField>>;
+
+private:
+	/**
+	 * Hash function for the field cache.
+	 */
+	struct pair_hash {
+		template <class T1, class T2>
+		std::size_t operator()(const std::pair<T1, T2> &pair) const {
+			return util::hash_combine(std::hash<T1>{}(pair.first), std::hash<T2>{}(pair.second));
+		}
+	};
+
+	/**
+	 * Cache for already computed fields.
+	 *
+	 * Key is the portal ID and the sector ID from which the field was entered. Fields that are cached are
+	 * cleared of dynamic flags, i.e. wavefront or LOS flags. These have to be recalculated
+	 * when the field is reused.
+	 */
+
+	std::unordered_map<std::pair<portal_id_t, sector_id_t>,
+	                   get_return_t,
+	                   pair_hash>
+		cache;
+};
+
+} // namespace path
+} // namespace openage