voxel_change_history.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "frustum.hpp"
 
#include <algorithm>
#include <cstdint>
#include <functional>
#include <glm/glm.hpp>
#include <iterator>
#include <memory>
#include <optional>
#include <span>
#include <toast/voxel/voxel_volume.hpp>
#include <vector>
 
namespace renderer {

struct VoxelRegion {
  uint64_t node_rid = 0;
  glm::vec3 min {0.0f};
  glm::vec3 max {0.0f};
};

class VoxelChangeHistory {
public:
  struct Entry {
    uint64_t generation = 0;
    std::shared_ptr<const std::vector<VoxelRegion>> regions;
  };
 
  static constexpr size_t k_max_entries = 32;
 
  [[nodiscard]]
  static auto extend(const VoxelChangeHistory& previous, uint64_t generation, std::vector<VoxelRegion> regions)
      -> VoxelChangeHistory;

  template<typename Visit>
  auto forEachSince(uint64_t generation, Visit&& visit) const -> bool {
    const auto known = std::ranges::find(m_entries, generation, &Entry::generation);
    if (known == m_entries.end()) {
      return false;
    }
    for (auto entry = std::next(known); entry != m_entries.end(); ++entry) {
      for (const VoxelRegion& region : *entry->regions) {
        visit(region);
      }
    }
    return true;
  }
 
private:
  std::vector<Entry> m_entries;
};
 
struct TrackedVolume {
  uint64_t node_rid = 0;
  const voxel::Volume* volume = nullptr;
};

using PublishedDims = std::function<std::optional<glm::uvec3>(uint64_t)>;

struct VolumeDelta {
  uint64_t node_rid = 0;

  bool unknown = false;

  std::vector<uint32_t> bricks;
};

class VoxelChangeTracker {
public:
  void observe(
      std::span<const TrackedVolume> volumes, const PublishedDims& published_dims, std::vector<VolumeDelta>* deltas = nullptr
  );

  auto packed(uint64_t generation) -> VoxelChangeHistory;

  void published();
 
  void reset();
 
private:
  struct Seen {
    uint64_t node_rid = 0;
    uint64_t volume_id = 0;
    uint32_t content = 0;
  };
 
  std::vector<Seen> m_seen;
  VoxelChangeHistory m_published;
  VoxelChangeHistory m_pending;
  std::vector<VoxelRegion> m_unpublished;
  bool m_has_pending = false;
};
 
struct VoxelCaster {
  uint64_t node_rid = 0;
  glm::mat4 model {1.0f};
};

[[nodiscard]]
auto regionsReach(
    const VoxelChangeHistory& history, uint64_t generation, std::span<const VoxelCaster> casters,
    std::span<const FrustumPlanes> views
) -> bool;
 
}