ernie-renderer 0.2.0.dev45__tar.gz → 0.2.0.dev52__tar.gz

{ernie_renderer-0.2.0.dev45 → ernie_renderer-0.2.0.dev52}/CMakeLists.txt

@@ -15,7 +15,7 @@ project(
 )
 
 # Pre-release suffix such as .dev12, written by CI.
-set(ERNIE_VERSION_SUFFIX ".dev45" CACHE STRING "Pre-release suffix of Ernie's version")
+set(ERNIE_VERSION_SUFFIX ".dev52" CACHE STRING "Pre-release suffix of Ernie's version")
 set(ERNIE_VERSION "${PROJECT_VERSION}${ERNIE_VERSION_SUFFIX}")
 
 option(ERNIE_BUILD_TESTS "Build Ernie's tests" OFF)

{ernie_renderer-0.2.0.dev45 → ernie_renderer-0.2.0.dev52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev45
+Version: 0.2.0.dev52
 Summary: Efficient Renderer for Natural and Interplanetary Environments: a physically based, spectral Vulkan ray tracer
 Author: Alex Maietta
 License-Expression: BSD-3-Clause

{ernie_renderer-0.2.0.dev45 → ernie_renderer-0.2.0.dev52}/benchmarks/scene/extents.cpp

@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
 namespace ernie::bench {
 namespace {

{ernie_renderer-0.2.0.dev45 → ernie_renderer-0.2.0.dev52}/benchmarks/scene/storage.cpp

@@ -25,7 +25,7 @@ struct Robots {
         transform = store->Tokens().Intern("xformOp:transform");
         bucket = store->AddBucket(
             {store->Tokens().Intern("Xform"), {}},
-            std::vector<ColumnLayout>{ColumnLayout::Of<glm::dmat4>(transform, glm::dmat4(1.0))});
+            std::vector<ColumnLayout>{ColumnLayout::Make<glm::dmat4>(transform, glm::dmat4(1.0))});
         prims.clear();
     }
 

{ernie_renderer-0.2.0.dev45 → ernie_renderer-0.2.0.dev52}/ernie/scene/CMakeLists.txt

@@ -2,6 +2,8 @@
 add_library(
     ernie_scene
     OBJECT
+    animation.cpp
+    edit_history.cpp
     extent_cache.cpp
     holder_index.cpp
     inherit.cpp
@@ -11,15 +13,14 @@ add_library(
     schema.cpp
     scene.cpp
     storage.cpp
+    time_samples.cpp
     usd_plugin.cpp
     validate.cpp
     view.cpp
     xform.cpp
     schemas/camera.cpp
-    schemas/collection.cpp
     schemas/geom.cpp
     schemas/instancer.cpp
-    schemas/laser.cpp
     schemas/lux.cpp
     schemas/mesh.cpp
     schemas/planet.cpp

ernie_renderer-0.2.0.dev52/ernie/scene/animation.cpp

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file animation.cpp
+/// @brief Time-sampled attributes: their sparse samples per prim, and the clock that evaluates
+/// them into the columns.
+#include "ernie/scene/scene.h"
+
+#include <algorithm>
+
+namespace ernie {
+
+void Scene::SetAt(PrimId prim, std::string_view attribute, double time, const Value& value) {
+    TimeSample sample{time, {}, {}};
+    Author(prim, attribute, value, &sample.value);
+    AddSample(prim, attribute, std::move(sample));
+}
+
+void Scene::WriteAt(PrimId prim, std::string_view attribute, double time, Tensor array) {
+    CheckArray(prim, attribute, array);
+    AddSample(prim, attribute, {time, {}, std::move(array)});
+}
+
+void Scene::AddSample(PrimId prim, std::string_view attribute, TimeSample sample) {
+    const AttributeId token = store_.Tokens().Intern(attribute);
+    Animated& animated = animated_[prim.slot];
+    animated.prim = prim;
+    std::vector<TimeSample>& samples = animated.samples[token];
+    // Samples are all values or all arrays: one of the other kind replaces them.
+    if (!samples.empty() && samples.front().tensor.Empty() != sample.tensor.Empty()) {
+        samples.clear();
+    }
+    const auto at = std::ranges::lower_bound(samples, sample.time, {}, &TimeSample::time);
+    if (at != samples.end() && at->time == sample.time) {
+        *at = std::move(sample);
+    } else {
+        samples.insert(at, std::move(sample));
+    }
+    Evaluate(prim, token, samples);
+}
+
+std::span<const TimeSample> Scene::Samples(PrimId prim, std::string_view attribute) const {
+    const auto animated = animated_.find(prim.slot);
+    const std::optional<Token> token = store_.Tokens().Find(attribute);
+    if (animated == animated_.end() || animated->second.prim != prim || !token) {
+        return {};
+    }
+    const auto samples = animated->second.samples.find(*token);
+    return samples == animated->second.samples.end() ? std::span<const TimeSample>()
+                                                     : std::span(samples->second);
+}
+
+std::optional<Value> Scene::GetAt(PrimId prim, std::string_view attribute, double time) const {
+    const std::span<const TimeSample> samples = Samples(prim, attribute);
+    if (samples.empty()) {
+        return Get(prim, attribute);
+    }
+    Value value = ernie::Evaluate(samples, time).value;
+    return value.Empty() ? std::nullopt : std::optional(std::move(value));
+}
+
+bool Scene::ClearSamples(PrimId prim, std::string_view attribute) {
+    if (Samples(prim, attribute).empty()) {
+        return false;
+    }
+    const auto animated = animated_.find(prim.slot);
+    animated->second.samples.erase(*store_.Tokens().Find(attribute));
+    if (animated->second.samples.empty()) {
+        animated_.erase(animated);
+    }
+    return true;
+}
+
+void Scene::SetTime(double timeCode) {
+    time_ = timeCode;
+    for (const auto& [slot, animated] : animated_) {
+        for (const auto& [attribute, samples] : animated.samples) {
+            Evaluate(animated.prim, attribute, samples);
+        }
+    }
+}
+
+void Scene::Evaluate(PrimId prim, AttributeId attribute, std::span<const TimeSample> samples) {
+    const std::string_view name = store_.Tokens().Text(attribute);
+    TimeSample now = ernie::Evaluate(samples, time_);
+    if (!now.tensor.Empty()) {
+        const Tensor* current = Read(prim, name);
+        if (current == nullptr || current->Data() != now.tensor.Data()) {
+            store_.Set(prim, attribute, std::move(now.tensor));
+        }
+    } else if (Get(prim, name) != now.value) {
+        Author(prim, name, now.value);
+    }
+}
+
+}  // namespace ernie

ernie_renderer-0.2.0.dev52/ernie/scene/edit_history.cpp

@@ -0,0 +1,225 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file edit_history.cpp
+/// @brief Recording edits as steps of before and after states, and applying them either way.
+#include "ernie/scene/edit_history.h"
+
+#include "ernie/util/text.h"
+
+#include <algorithm>
+#include <stdexcept>
+
+namespace ernie {
+
+void EditHistory::Set(Scene& scene, const Path& path,
+                      std::vector<std::pair<std::string, Value>> edits, bool open) {
+    const PrimId prim = scene.Require(path);
+    Step step{.path = path, .open = open};
+    try {
+        for (auto& [name, value] : edits) {
+            Cell before = Capture(scene, prim, name);
+            scene.Set(prim, name, std::move(value));
+            step.attributes.push_back({name, std::move(before), Capture(scene, prim, name)});
+        }
+    } catch (...) {
+        // What applied before the rejected edit stays undoable.
+        if (!step.attributes.empty()) {
+            Push(std::move(step));
+        }
+        throw;
+    }
+    const auto same = [&](const Step& last) {
+        return !last.structural && last.open && last.path == path &&
+               std::ranges::equal(last.attributes, step.attributes, {}, &AttributeEdit::name,
+                                  &AttributeEdit::name);
+    };
+    if (open && open_ && next_ == steps_.size() && !steps_.empty() && same(steps_.back())) {
+        for (std::size_t i = 0; i < step.attributes.size(); ++i) {
+            steps_.back().attributes[i].after = std::move(step.attributes[i].after);
+        }
+        return;
+    }
+    Push(std::move(step));
+}
+
+void EditHistory::Clear(Scene& scene, const Path& path, std::string_view attribute) {
+    const PrimId prim = scene.Require(path);
+    const std::string name(attribute);
+    Cell before = Capture(scene, prim, name);
+    scene.Clear(prim, attribute);
+    Push({.path = path, .attributes = {{name, std::move(before), Capture(scene, prim, name)}}});
+}
+
+void EditHistory::Define(Scene& scene, const Path& path, std::string_view type) {
+    if (scene.Has(path)) {
+        throw std::invalid_argument("'" + path.String() + "' has a prim already");
+    }
+    scene.Define(path, type);
+    Push({.path = path, .after = Snapshot(scene, path), .structural = true});
+}
+
+bool EditHistory::Remove(Scene& scene, const Path& path) {
+    if (!scene.Has(path)) {
+        return false;
+    }
+    Step step{.path = path, .before = Snapshot(scene, path), .structural = true};
+    scene.Remove(path);
+    Push(std::move(step));
+    return true;
+}
+
+void EditHistory::Add(Scene& scene, const Scene& source, const Path& path) {
+    if (!source.Has(path) || scene.Has(path)) {
+        throw std::invalid_argument("Cannot add '" + path.String() +
+                                    "': the source has no prim there or the scene has one");
+    }
+    Step step{.path = path, .after = Snapshot(source, path), .structural = true};
+    Restore(scene, step.after);
+    Push(std::move(step));
+}
+
+void EditHistory::BeginGroup() {
+    if (groupDepth_++ == 0) {
+        group_ = nextGroup_++;
+    }
+}
+
+void EditHistory::EndGroup() {
+    if (groupDepth_ > 0 && --groupDepth_ == 0) {
+        group_ = 0;
+    }
+}
+
+bool EditHistory::Undo(Scene& scene) {
+    return Move(scene, false);
+}
+
+bool EditHistory::Redo(Scene& scene) {
+    return Move(scene, true);
+}
+
+std::string EditHistory::UndoLabel() const {
+    return CanUndo() ? Label(steps_[next_ - 1]) : std::string();
+}
+
+std::string EditHistory::RedoLabel() const {
+    return CanRedo() ? Label(steps_[next_]) : std::string();
+}
+
+void EditHistory::Reset() {
+    *this = EditHistory();
+}
+
+EditHistory::Cell EditHistory::Capture(const Scene& scene, PrimId prim,
+                                       const std::string& attribute) {
+    Cell cell;
+    const std::span<const TimeSample> samples = scene.Samples(prim, attribute);
+    cell.samples.assign(samples.begin(), samples.end());
+    if (const Tensor* array = scene.Read(prim, attribute)) {
+        cell.array = *array;
+    } else {
+        cell.value = scene.Get(prim, attribute);
+    }
+    return cell;
+}
+
+void EditHistory::Apply(Scene& scene, PrimId prim, const std::string& attribute, const Cell& cell) {
+    if (!cell.samples.empty()) {
+        scene.ClearSamples(prim, attribute);
+        for (const TimeSample& sample : cell.samples) {
+            sample.tensor.Empty() ? scene.SetAt(prim, attribute, sample.time, sample.value)
+                                  : scene.WriteAt(prim, attribute, sample.time, sample.tensor);
+        }
+    } else if (!cell.array.Empty()) {
+        scene.Write(prim, attribute, cell.array);
+    } else if (cell.value) {
+        scene.Set(prim, attribute, *cell.value);
+    } else {
+        scene.Clear(prim, attribute);
+    }
+}
+
+std::vector<EditHistory::PrimSnapshot> EditHistory::Snapshot(const Scene& scene, const Path& path) {
+    std::vector<PrimSnapshot> prims;
+    std::vector<Path> pending{path};
+    while (!pending.empty()) {
+        const Path next = std::move(pending.back());
+        pending.pop_back();
+        const PrimId prim = scene.Require(next);
+        PrimSnapshot& snapshot = prims.emplace_back();
+        snapshot.path = next;
+        snapshot.type = std::string(scene.TypeName(prim));
+        snapshot.apis = scene.AppliedApis(prim);
+        for (const std::string& name : scene.Attributes(next)) {
+            snapshot.attributes.emplace(name, Capture(scene, prim, name));
+        }
+        const std::vector<Path> children = scene.Children(next);
+        pending.insert(pending.end(), children.rbegin(), children.rend());
+    }
+    return prims;
+}
+
+void EditHistory::Restore(Scene& scene, const std::vector<PrimSnapshot>& prims) {
+    for (const PrimSnapshot& snapshot : prims) {
+        const PrimId prim = scene.Define(snapshot.path, snapshot.type);
+        for (const std::string& api : snapshot.apis) {
+            scene.ApplyApi(prim, api);
+        }
+        for (const auto& [name, cell] : snapshot.attributes) {
+            Apply(scene, prim, name, cell);
+        }
+    }
+}
+
+void EditHistory::Apply(Scene& scene, const Step& step, bool forward) {
+    if (step.structural) {
+        scene.Remove(step.path);
+        Restore(scene, forward ? step.after : step.before);
+        return;
+    }
+    // Edits of a prim removed since are skipped.
+    const std::optional<PrimId> prim = scene.Find(step.path);
+    if (!prim) {
+        return;
+    }
+    for (std::size_t i = 0; i < step.attributes.size(); ++i) {
+        const AttributeEdit& edit = step.attributes[forward ? i : step.attributes.size() - 1 - i];
+        Apply(scene, *prim, edit.name, forward ? edit.after : edit.before);
+    }
+}
+
+void EditHistory::Push(Step step) {
+    steps_.resize(next_);
+    step.group = groupDepth_ > 0 ? group_ : 0;
+    open_ = step.open;
+    steps_.push_back(std::move(step));
+    next_ = steps_.size();
+}
+
+bool EditHistory::Move(Scene& scene, bool forward) {
+    open_ = false;
+    if (forward ? !CanRedo() : !CanUndo()) {
+        return false;
+    }
+    const std::uint64_t group = steps_[forward ? next_ : next_ - 1].group;
+    do {
+        if (forward) {
+            Apply(scene, steps_[next_++], true);
+        } else {
+            Apply(scene, steps_[--next_], false);
+        }
+    } while (group != 0 && (forward ? CanRedo() && steps_[next_].group == group
+                                    : CanUndo() && steps_[next_ - 1].group == group));
+    return true;
+}
+
+std::string EditHistory::Label(const Step& step) {
+    if (step.structural) {
+        return (step.before.empty()  ? "Add "
+                : step.after.empty() ? "Remove "
+                                     : "Change ") +
+               step.path.String();
+    }
+    return step.path.String() + " " + Join(step.attributes, " ", &AttributeEdit::name);
+}
+
+}  // namespace ernie

ernie_renderer-0.2.0.dev52/ernie/scene/edit_history.h

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file edit_history.h
+/// @brief Undo and redo of scene edits, for the viewer.
+///
+/// References:
+/// - E. Gamma, R. Helm, R. Johnson and J. Vlissides, "Design Patterns", the Command pattern,
+///   Addison-Wesley, 1994.
+#pragma once
+
+#include "ernie/scene/scene.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <map>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace ernie {
+
+/// @brief Undo and redo for the edits made through it: attributes set or cleared, prims defined,
+/// removed with their descendants, or copied in. Each step records what it changes, so `Undo`
+/// puts it back and `Redo` does it again.
+///
+/// Continuous edits, as dragging a slider or a gizmo, merge into one step: an `open` edit of the
+/// same attributes as the last step updates it until `Close`. Edits between `BeginGroup` and
+/// `EndGroup` undo and redo together. Edits made to the scene directly are not recorded.
+class EditHistory {
+  public:
+    /// @brief Sets attributes of a prim as one step, dropping the undone steps. With `open`, merges
+    /// into the last step if that is an open edit of the same attributes.
+    /// @throws std::invalid_argument as `Scene::Set`.
+    void Set(Scene& scene, const Path& path, std::vector<std::pair<std::string, Value>> edits,
+             bool open = false);
+    void Set(Scene& scene, const Path& path, std::string_view attribute, Value value,
+             bool open = false) {
+        Set(scene, path, {{std::string(attribute), std::move(value)}}, open);
+    }
+    /// @brief Unauthors an attribute, back to its fallback.
+    void Clear(Scene& scene, const Path& path, std::string_view attribute);
+    /// @brief Defines a new prim; undoing removes it.
+    /// @throws std::invalid_argument as `Scene::Define`, or if a prim is there already.
+    void Define(Scene& scene, const Path& path, std::string_view type);
+    /// @brief Removes a prim and its descendants; undoing restores them, sharing their arrays.
+    /// @return Whether there was a prim.
+    bool Remove(Scene& scene, const Path& path);
+    /// @brief Copies a prim of `source` and its descendants to the same path of `scene`, as for
+    /// prims authored in a scratch scene first; undoing removes them.
+    /// @throws std::invalid_argument if `source` has no prim at `path` or `scene` has one.
+    void Add(Scene& scene, const Scene& source, const Path& path);
+
+    /// Groups the edits until `EndGroup` into one step. Groups nest; the outermost counts.
+    void BeginGroup();
+    void EndGroup();
+    /// Ends the open step, so the next edit starts a new one.
+    void Close() {
+        open_ = false;
+    }
+
+    bool CanUndo() const {
+        return next_ > 0;
+    }
+    bool CanRedo() const {
+        return next_ < steps_.size();
+    }
+    /// @brief Undoes the last step or group; edits of prims removed since are skipped.
+    /// @return Whether there was one.
+    bool Undo(Scene& scene);
+    bool Redo(Scene& scene);
+    /// @return What `Undo` or `Redo` would do, as "/World/Cube xformOp:translate".
+    std::string UndoLabel() const;
+    std::string RedoLabel() const;
+    /// Forgets every step, as when the viewer switches scenes.
+    void Reset();
+    /// @return The steps recorded, a group's edits each counted.
+    std::size_t Size() const {
+        return steps_.size();
+    }
+
+  private:
+    /// One attribute's authored state: unset, a value, an array or time samples.
+    struct Cell {
+        std::optional<Value> value;
+        Tensor array;
+        std::vector<TimeSample> samples;
+    };
+    /// One prim of a subtree, enough to define it again.
+    struct PrimSnapshot {
+        Path path;
+        std::string type;
+        std::vector<std::string> apis;
+        std::map<std::string, Cell> attributes;
+    };
+    struct AttributeEdit {
+        std::string name;
+        Cell before;
+        Cell after;
+    };
+    struct Step {
+        Path path;
+        std::vector<AttributeEdit> attributes;
+        /// Structure steps: the subtree at `path` before and after, parents first; empty for none.
+        std::vector<PrimSnapshot> before;
+        std::vector<PrimSnapshot> after;
+        bool structural = false;
+        bool open = false;
+        /// Steps of one non-zero group undo together.
+        std::uint64_t group = 0;
+    };
+
+    static Cell Capture(const Scene& scene, PrimId prim, const std::string& attribute);
+    static void Apply(Scene& scene, PrimId prim, const std::string& attribute, const Cell& cell);
+    static std::vector<PrimSnapshot> Snapshot(const Scene& scene, const Path& path);
+    static void Restore(Scene& scene, const std::vector<PrimSnapshot>& prims);
+    static void Apply(Scene& scene, const Step& step, bool forward);
+    void Push(Step step);
+    bool Move(Scene& scene, bool forward);
+    static std::string Label(const Step& step);
+
+    std::vector<Step> steps_;
+    /// Steps before it are done; from it on, undone.
+    std::size_t next_ = 0;
+    bool open_ = false;
+    int groupDepth_ = 0;
+    std::uint64_t group_ = 0;
+    std::uint64_t nextGroup_ = 1;
+};
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev45 → ernie_renderer-0.2.0.dev52}/ernie/scene/extent_cache.cpp

@@ -14,28 +14,20 @@ void ExtentCache::Track(BucketId bucket, ExtentFunction compute) {
 
 void ExtentCache::Update(const PrimStore& store) {
     const ChangeSet changes = store.ChangesSince(cursor_);
-    const auto tracked = [&](BucketId bucket) {
-        return bucket < buckets_.size() && buckets_[bucket].compute != nullptr;
-    };
-    for (const BucketId bucket : changes.resets) {
-        if (tracked(bucket)) {
-            Resize(buckets_[bucket], 0);
-        }
-    }
     for (const ChangeSet::Rows& rows : changes.rows) {
-        if (tracked(rows.bucket)) {
+        if (Tracked(rows.bucket)) {
             Replay(buckets_[rows.bucket], rows.change);
         }
     }
     for (const ChangeSet::Values& values : changes.values) {
-        if (tracked(values.bucket)) {
+        if (Tracked(values.bucket)) {
             for (const RowRange range : values.rows) {
                 buckets_[values.bucket].stale.SetRange(range.begin, range.end);
             }
         }
     }
     for (BucketId bucket = 0; bucket < buckets_.size(); ++bucket) {
-        if (tracked(bucket) && store.GetBucket(bucket).version > cursor_) {
+        if (Tracked(bucket) && store.GetBucket(bucket).version > cursor_) {
             Refresh(buckets_[bucket], store, bucket);
         }
     }
@@ -44,16 +36,23 @@ void ExtentCache::Update(const PrimStore& store) {
 
 std::optional<Box> ExtentCache::Find(const PrimStore& store, BucketId bucket,
                                      std::uint32_t row) const {
-    if (bucket >= buckets_.size() || buckets_[bucket].compute == nullptr ||
-        store.GetBucket(bucket).version > cursor_ || row >= buckets_[bucket].boxes.size()) {
+    if (!Tracked(bucket) || store.GetBucket(bucket).version > cursor_ ||
+        row >= buckets_[bucket].boxes.size()) {
         return std::nullopt;
     }
     return buckets_[bucket].boxes[row];
 }
 
+bool ExtentCache::Tracked(BucketId bucket) const {
+    return bucket < buckets_.size() && buckets_[bucket].compute != nullptr;
+}
+
 void ExtentCache::Replay(Entry& entry, const StructuralChange& change) {
     using Kind = StructuralChange::Kind;
-    if (change.kind == Kind::Added) {
+    if (change.kind == Kind::Reset) {
+        Resize(entry, 0);
+    }
+    if (change.kind == Kind::Added || change.kind == Kind::Reset) {
         Resize(entry, change.row + change.count);
         entry.stale.SetRange(change.row, change.row + change.count);
     } else if (change.kind == Kind::Moved) {
@@ -72,12 +71,6 @@ void ExtentCache::Resize(Entry& entry, std::uint32_t rows) {
 }
 
 void ExtentCache::Refresh(Entry& entry, const PrimStore& store, BucketId bucket) {
-    const std::uint32_t rows = store.GetBucket(bucket).Rows();
-    if (entry.boxes.size() != rows) {
-        // Too far behind to replay (a reset): recompute the bucket whole.
-        Resize(entry, rows);
-        entry.stale.SetRange(0, rows);
-    }
     const ExtentRows columns{store, bucket};
     entry.stale.ForEachRun([&](std::size_t begin, std::size_t end) {
         entry.compute(columns, {static_cast<std::uint32_t>(begin), static_cast<std::uint32_t>(end)},

{ernie_renderer-0.2.0.dev45 → ernie_renderer-0.2.0.dev52}/ernie/scene/extent_cache.h

@@ -32,6 +32,7 @@ class ExtentCache {
         BitSet stale;
     };
 
+    bool Tracked(BucketId bucket) const;
     static void Replay(Entry& entry, const StructuralChange& change);
     static void Resize(Entry& entry, std::uint32_t rows);
     static void Refresh(Entry& entry, const PrimStore& store, BucketId bucket);

{ernie_renderer-0.2.0.dev45 → ernie_renderer-0.2.0.dev52}/ernie/scene/holder_index.cpp

@@ -3,6 +3,8 @@
 /// @brief Re-indexing changed relationship cells, and finding a target's live holders.
 #include "ernie/scene/holder_index.h"
 
+#include "ernie/util/algorithm.h"
+
 #include <algorithm>
 #include <unordered_set>
 
@@ -16,18 +18,28 @@ bool IsRelationship(ColumnType type) {
 /// @return The targets of a relationship cell, without the unset one.
 std::vector<PathId> Targets(const PrimStore& store, BucketId bucket, const Column& column,
                             std::uint32_t row) {
-    std::vector<PathId> targets;
-    if (column.values->Type() == ColumnType::Relationship) {
-        targets.push_back(store.Read<Target>(bucket, column.attribute)[row].path);
-    } else {
-        for (const Target target : store.Read<std::vector<Target>>(bucket, column.attribute)[row]) {
-            targets.push_back(target.path);
-        }
-    }
+    std::vector<PathId> targets =
+        column.values->Type() == ColumnType::Relationship
+            ? std::vector<PathId>{store.Read<Target>(bucket, column.attribute)[row].path}
+            : Map(store.Read<std::vector<Target>>(bucket, column.attribute)[row], &Target::path);
     std::erase(targets, kNoPath);
     return targets;
 }
 
+/// @return Whether the prim is alive and its relationship still targets `target`.
+bool Holds(const PrimStore& store, PrimId prim, AttributeId attribute, PathId target) {
+    if (!store.Alive(prim)) {
+        return false;
+    }
+    const BucketId bucket = store.PrimBucket(prim);
+    const Column* column = store.GetBucket(bucket).Find(attribute);
+    if (column == nullptr || !IsRelationship(column->values->Type())) {
+        return false;
+    }
+    const std::vector<PathId> targets = Targets(store, bucket, *column, store.PrimRow(prim));
+    return std::ranges::find(targets, target) != targets.end();
+}
+
 }  // namespace
 
 void HolderIndex::Update(const PrimStore& store) {
@@ -39,22 +51,12 @@ void HolderIndex::Update(const PrimStore& store) {
             continue;
         }
         for (const RowRange range : values.rows) {
-            for (std::uint32_t row = range.begin; row < std::min(range.end, bucket.Rows()); ++row) {
+            for (std::uint32_t row = range.begin; row < range.end; ++row) {
                 Index(bucket.prims[row], values.attribute,
                       Targets(store, values.bucket, column, row));
             }
         }
     }
-    // A bucket too far behind to replay reports every row of every column, as a fresh one does.
-    for (const BucketId id : changes.resets) {
-        const Bucket& bucket = store.GetBucket(id);
-        for (const Column& column : bucket.columns) {
-            for (std::uint32_t row = 0;
-                 IsRelationship(column.values->Type()) && row < bucket.Rows(); ++row) {
-                Index(bucket.prims[row], column.attribute, Targets(store, id, column, row));
-            }
-        }
-    }
     cursor_ = changes.version;
 }
 
@@ -95,17 +97,4 @@ std::vector<PrimId> HolderIndex::Find(const PrimStore& store, PathId target) con
     return found;
 }
 
-bool HolderIndex::Holds(const PrimStore& store, PrimId prim, AttributeId attribute, PathId target) {
-    if (!store.Alive(prim)) {
-        return false;
-    }
-    const BucketId bucket = store.PrimBucket(prim);
-    const Column* column = store.GetBucket(bucket).Find(attribute);
-    if (column == nullptr || !IsRelationship(column->values->Type())) {
-        return false;
-    }
-    const std::vector<PathId> targets = Targets(store, bucket, *column, store.PrimRow(prim));
-    return std::ranges::find(targets, target) != targets.end();
-}
-
 }  // namespace ernie