FieldState.h

#pragma once
 
#include "Bump.h"
#include "HashGrid.h"
#include "TiledGrid.h"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <fhsim_environment/AggregationField.h>
#include <memory>
#include <optional>
#include <vector>
 
namespace environment::field
{
 
struct AggregationField::State
{
   std::array<double, 3>              origin {0.0, 0.0, 0.0}; 
   std::vector<float>                 x, y, z, a, b, c, cosPhi, sinPhi, amp;
   std::vector<aggregation::Box>      boxes;
   std::vector<Aggregation>           shapes;       
   std::vector<std::array<double, 2>> patchCentres; 
   std::vector<std::size_t>           patchIndices; 
   aggregation::HashGrid              grid;
   double                             totalMass = 0.0;
 
   // The keyed store (ApplyChanges); unused while keyed is false.
   bool                       keyed = false;
   aggregation::TiledGrid     tiled; 
   std::vector<AggregationId> ids;   
   std::vector<std::uint8_t>  live;  
   std::size_t                liveCount = 0;
   AggregationId              nextId    = 0; 
 
   [[nodiscard]] std::size_t Size() const { return keyed ? liveCount : x.size(); }
 
   [[nodiscard]] std::size_t SlotCount() const { return x.size(); }
 
   [[nodiscard]] bool IsLive(std::size_t slot) const { return !keyed || live[slot] != 0; }
 
   [[nodiscard]] AggregationId NextId() const { return keyed ? nextId : static_cast<AggregationId>(x.size()); }
 
   [[nodiscard]] aggregation::Bump Load(std::size_t i) const
   {
      return {x[i], y[i], z[i], a[i], b[i], c[i], cosPhi[i], sinPhi[i], amp[i]};
   }
 
   template<class Visitor>
   void ForEachCandidate(const aggregation::Box& query, Visitor&& visit) const
   {
      if (keyed) {
         tiled.ForEachCandidate(query, visit);
      } else {
         grid.ForEachCandidate(query, visit);
      }
   }
 
   void Candidates(const aggregation::Box& query, std::vector<std::uint32_t>& out) const
   {
      if (keyed) {
         tiled.Candidates(query, out);
      } else {
         grid.Candidates(query, out);
      }
   }
 
   [[nodiscard]] std::vector<double> SlotMassInBox(const OrientedBox& box) const;
 
   // Keyed store helpers (AggregationFieldChanges.cpp).
 
   void WriteSlot(std::size_t slot, const Aggregation& aggregation);
 
   [[nodiscard]] double LiveMass() const;
 
   [[nodiscard]] std::optional<std::size_t> SlotOf(AggregationId id) const;
 
   [[nodiscard]] AggregationId IdOf(std::size_t slot) const { return keyed ? ids[slot] : static_cast<AggregationId>(slot); }
 
   [[nodiscard]] std::vector<aggregation::TiledGrid::Item> AllItems() const;
 
   [[nodiscard]] aggregation::TiledGrid FirstGrid(const std::optional<AggregationGridBounds>& bounds) const;
 
   [[nodiscard]] std::shared_ptr<State> CopyWithRoom(std::size_t extra) const;
 
   [[nodiscard]] std::shared_ptr<State> Compacted() const;
};
 
[[nodiscard]] const char* AggregationProblem(const Aggregation& aggregation);
 
} // namespace environment::field