terraingenpy 0.1.1.dev20__tar.gz → 0.1.1.dev23__tar.gz

{terraingenpy-0.1.1.dev20 → terraingenpy-0.1.1.dev23}/CHANGELOG.md

@@ -35,6 +35,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Freshness degradation never makes a crater deeper than fresh: basins shallower than the cutoff keep their fresh shape.
 - Small craters inside larger ones on sloping ground no longer stand as raised mounds: datums are fitted to the slope-shaped relief that is applied.
+- Crater layers over other layers read the ground beneath their slopes and datums in batches rather than point by point, and point batches are evaluated in spatial order: the hero demo went from 433 s to 11 s with the same output.
 
 ## [0.1.0] - 2026-10-18
 

{terraingenpy-0.1.1.dev20 → terraingenpy-0.1.1.dev23}/CMakeLists.txt

@@ -8,7 +8,7 @@ endif()
 
 # The release being worked towards, such as 0.1.0, or for a development build a PEP 440 pre-release of
 # it, such as 0.1.0.dev42, which only the Python package carries.
-set(TERRAINGEN_FULL_VERSION "0.1.1.dev20")
+set(TERRAINGEN_FULL_VERSION "0.1.1.dev23")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" TERRAINGEN_VERSION "${TERRAINGEN_FULL_VERSION}")
 
 project(

{terraingenpy-0.1.1.dev20 → terraingenpy-0.1.1.dev23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: terraingenpy
-Version: 0.1.1.dev20
+Version: 0.1.1.dev23
 Summary: Scientific terrain generation for planetary surfaces
 Keywords: terrain,moon,mars,craters,planetary science,simulation
 Author: Alex Maietta
@@ -64,7 +64,9 @@ Description-Content-Type: text/markdown
 
 # TerrainGen
 
-![]()
+![Blue Moon MK1 SN101 lander at Connecting Ridge, with Mons Malapert in the background](docs/images/hero_mk1_sn101_connecting_ridge.jpg)
+
+*Blue Moon MK1 SN101 lander at Connecting Ridge near the lunar south pole, with Mons Malapert in the background. Terrain upscaled by TerrainGen from LOLA elevation models.*
 
 A high-performance scientific terrain generation tool for interplanetary bodies.
 

{terraingenpy-0.1.1.dev20 → terraingenpy-0.1.1.dev23}/README.md

@@ -8,7 +8,9 @@
 
 # TerrainGen
 
-![]()
+![Blue Moon MK1 SN101 lander at Connecting Ridge, with Mons Malapert in the background](docs/images/hero_mk1_sn101_connecting_ridge.jpg)
+
+*Blue Moon MK1 SN101 lander at Connecting Ridge near the lunar south pole, with Mons Malapert in the background. Terrain upscaled by TerrainGen from LOLA elevation models.*
 
 A high-performance scientific terrain generation tool for interplanetary bodies.
 

terraingenpy-0.1.1.dev23/assets/textures/README.md

@@ -0,0 +1,14 @@
+# Textures
+
+Tileable detail textures for terrain and rock materials, stored in Git LFS.
+
+| Files | Source | License |
+| --- | --- | --- |
+| `moon_01_diff_4k.jpg`, `moon_01_nor_gl_4k.exr`, `moon_01_rough_4k.exr`, `moon_01_disp_4k.png` | Poly Haven, "Moon 01" by Greg Zaal, Rico Cilliers and Jenelle van Heerden (photography) and Dario Barresi (processing), <https://polyhaven.com/a/moon_01> | CC0 1.0 |
+| `seaside_rock_diff_2k.png`, `seaside_rock_nor_gl_2k.exr`, `seaside_rock_nor_dx_2k.exr`, `seaside_rock_rough_2k.exr`, `seaside_rock_ao_2k.png`, `seaside_rock_arm_2k.png`, `seaside_rock_disp_2k.png` | Poly Haven, "Seaside Rock", <https://polyhaven.com/a/seaside_rock> | CC0 1.0 |
+The moon_01 scan covers about 3.1 m of lunar regolith per tile: diffuse colour (sRGB), OpenGL
+normal map, roughness and displacement, at 4096 x 4096.
+
+The seaside rock maps are 2048 x 2048 (diffuse sRGB; OpenGL and DirectX normal maps; roughness,
+ambient occlusion, packed AO/roughness/metal and displacement). The lunar_regolith maps are
+8192 x 8192 (diffuse sRGB, OpenGL normal map, roughness, 16-bit ambient occlusion).

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_ao_2k.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f907a0905707a4eeeeedd2c22e98ac616df42a3cd9851057abd72182fe443e31
+size 7393858

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_arm_2k.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:995985a315fade7b3a6e201419ba98d18316732246acfed2536327e52618ef71
+size 16682666

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_diff_2k.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2263535252e356c57f47861e16c45c0875eb83c6d5ba95180f551b681a561f0d
+size 22995458

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_disp_2k.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c80a1449d2e32d29bab0730f5369fc355825f20873e37ffe16e3357ad606e648
+size 6170255

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_nor_dx_2k.exr

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7beaf1c752a80dbd5861843f5ae3d6e3c816e9b2225ab4881b5a4da008b6ff8
+size 9124350

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_nor_gl_2k.exr

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:112b3b036cbca6098083754f626485e1fa0f2843782a4a6d8328b62b1b83ea13
+size 9109880

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_rough_2k.exr

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:543c1863afe8702c8c51f05f453309e3ae0c8f827269e0b8f05bb0f2a1a06ff1
+size 1585214

{terraingenpy-0.1.1.dev20 → terraingenpy-0.1.1.dev23}/terraingen/layers/craters/crater_layer.cpp

@@ -191,6 +191,9 @@ void CraterLayer::ApplySamples(SampleBlock& samples, const LayerContext& context
     const HeightSampler ground =
         context.ground ? context.ground->Sampler(spacing) : HeightSampler{};
     CraterSampling sampling{spacing, context.threads, ground};
+    if (context.ground != nullptr) {
+        sampling.groundBatch = context.ground->BatchSampler(spacing);
+    }
     sampling.cache = context.cache;
     sampling.owner = this;
     sampling.backend = context.backend;

{terraingenpy-0.1.1.dev20 → terraingenpy-0.1.1.dev23}/terraingen/layers/craters/shaping/apply.cpp

@@ -318,13 +318,14 @@ std::optional<DatumKernelIndex> IndexDatumRelief(const std::vector<PreparedCrate
 }
 
 /// Fits the datums of craters `fitted` of `prepared`, all indexed in `index`: the ground under
-/// each lattice point is read, the relief of the craters before each crater added by
+/// each lattice point is read (in one pass by `batchGround` when given, else by `ground`), the
+/// relief of the craters before each crater added by
 /// `KernelDatumRelief` on GPU `backend` when it can take it and on CPU threads otherwise, and the
 /// fit solved in double.
 void FitDatumsWithKernel(std::vector<PreparedCrater>& prepared,
                          const std::vector<std::size_t>& fitted, const HeightSampler& ground,
-                         const DatumKernelIndex& index, const CraterApplyOptions& options,
-                         Backend backend, unsigned threads) {
+                         const HeightsSampler& batchGround, const DatumKernelIndex& index,
+                         const CraterApplyOptions& options, Backend backend, unsigned threads) {
     constexpr auto kPoints = static_cast<std::size_t>(kDatumLatticeSide * kDatumLatticeSide);
     Raster<float> lattice(kPoints, fitted.size(), 0.0f);
     std::vector<std::uint8_t> valid(lattice.Size(), 0);
@@ -341,16 +342,35 @@ void FitDatumsWithKernel(std::vector<PreparedCrater>& prepared,
             }
         }
     };
-    ParallelFor(fitted.size(), threads, [&](std::size_t n) {
-        const Crater& c = prepared[fitted[n]].crater;
-        forEachPoint(n, [&](std::size_t at, double dx, double dy) {
-            const float height = ground(c.x + dx, c.y + dy);
-            if (!std::isnan(height)) {
-                lattice.Values()[at] = height;
-                valid[at] = 1;
-            }
+    const auto keep = [&](std::size_t at, float height) {
+        if (!std::isnan(height)) {
+            lattice.Values()[at] = height;
+            valid[at] = 1;
+        }
+    };
+    if (batchGround) {
+        std::vector<Vec2d> points;
+        std::vector<std::size_t> slots;
+        for (std::size_t n = 0; n < fitted.size(); ++n) {
+            const Crater& c = prepared[fitted[n]].crater;
+            forEachPoint(n, [&](std::size_t at, double dx, double dy) {
+                points.push_back({c.x + dx, c.y + dy});
+                slots.push_back(at);
+            });
+        }
+        std::vector<float> heights(points.size());
+        batchGround(points, heights);
+        for (std::size_t i = 0; i < points.size(); ++i) {
+            keep(slots[i], heights[i]);
+        }
+    } else {
+        ParallelFor(fitted.size(), threads, [&](std::size_t n) {
+            const Crater& c = prepared[fitted[n]].crater;
+            forEachPoint(n, [&](std::size_t at, double dx, double dy) {
+                keep(at, ground(c.x + dx, c.y + dy));
+            });
         });
-    });
+    }
     std::vector<std::uint32_t> targets(fitted.size());
     for (std::size_t n = 0; n < fitted.size(); ++n) {
         targets[n] = index.slot[fitted[n]];
@@ -403,20 +423,37 @@ void FitDatumsWithKernel(std::vector<PreparedCrater>& prepared,
 /// datum is fitted, so the relief datums are fitted to is the relief applied, and each crater's
 /// slope depends on no other crater of its layer.
 void ShapeOnSlopes(std::vector<PreparedCrater>& prepared, const HeightSampler& ground,
-                   const DegradationModel& degradation, const CraterApplyOptions& options) {
+                   const HeightsSampler& batch, const DegradationModel& degradation,
+                   const CraterApplyOptions& options) {
     const CraterSlopeResponse& response = options.slope;
     if (!response.enabled && !response.criticalGradient) {
         return;
     }
-    for (PreparedCrater& crater : prepared) {
+    std::vector<Vec2d> points;
+    points.reserve(4 * prepared.size());
+    for (const PreparedCrater& crater : prepared) {
         const Crater& c = crater.crater;
         const double half = options.datumFitRadii * 0.5 * c.diameter;
-        const auto at = [&](double east, double north) {
-            const Vec2d p = options.surface.Locate({c.x, c.y}, {east, north});
-            return static_cast<double>(ground(p.x, p.y));
-        };
-        const double east = (at(half, 0.0) - at(-half, 0.0)) / (2.0 * half);
-        const double north = (at(0.0, half) - at(0.0, -half)) / (2.0 * half);
+        for (const Vec2d offset :
+             {Vec2d{half, 0.0}, Vec2d{-half, 0.0}, Vec2d{0.0, half}, Vec2d{0.0, -half}}) {
+            points.push_back(options.surface.Locate({c.x, c.y}, offset));
+        }
+    }
+    std::vector<float> heights(points.size());
+    if (batch) {
+        batch(points, heights);
+    } else {
+        for (std::size_t i = 0; i < points.size(); ++i) {
+            heights[i] = ground(points[i].x, points[i].y);
+        }
+    }
+    for (std::size_t k = 0; k < prepared.size(); ++k) {
+        PreparedCrater& crater = prepared[k];
+        const Crater& c = crater.crater;
+        const double half = options.datumFitRadii * 0.5 * c.diameter;
+        const auto at = [&](std::size_t n) { return static_cast<double>(heights[4 * k + n]); };
+        const double east = (at(0) - at(1)) / (2.0 * half);
+        const double north = (at(2) - at(3)) / (2.0 * half);
         if (!std::isfinite(east) || !std::isfinite(north)) {
             continue;
         }
@@ -446,8 +483,9 @@ void FitDatums(std::vector<PreparedCrater>& prepared, const std::vector<std::siz
     if (shape && options.datum != CraterDatum::CentreHeight) {
         if (const std::optional<DatumKernelIndex> index =
                 IndexDatumRelief(prepared, fitted, profile, *shape, options)) {
-            FitDatumsWithKernel(prepared, fitted, ground, *index, options, sampling.backend,
-                                sampling.threads);
+            FitDatumsWithKernel(prepared, fitted, ground,
+                                sampling.ground ? sampling.groundBatch : HeightsSampler{}, *index,
+                                options, sampling.backend, sampling.threads);
             return;
         }
     }
@@ -687,7 +725,8 @@ void ApplyCraters(Raster<float>& raster, const CraterList& craters, const Crater
                 return static_cast<float>(
                     Sample(raster, x, y).value_or(std::numeric_limits<double>::quiet_NaN()));
             });
-        ShapeOnSlopes(prepared, beneath, *models.degradation, options);
+        ShapeOnSlopes(prepared, beneath, sampling.ground ? sampling.groundBatch : HeightsSampler{},
+                      *models.degradation, options);
         FitDatums(prepared, onRaster, raster, profile, kernel, options, sampling);
     }
     if (kernel) {
@@ -741,7 +780,8 @@ void ApplyCraters(SampleBlock& samples, const CraterList& craters, const CraterS
         indices.push_back(static_cast<std::size_t>(crater.prepared - prepared.data()));
     }
     if (options.datum != CraterDatum::None && !reaching.empty()) {
-        ShapeOnSlopes(prepared, sampling.ground, *models.degradation, options);
+        ShapeOnSlopes(prepared, sampling.ground, sampling.groundBatch, *models.degradation,
+                      options);
         std::optional<DatumKernelIndex> kernelIndex;
         bool indexed = false;
         std::optional<CraterReliefIndex> index;
@@ -752,8 +792,8 @@ void ApplyCraters(SampleBlock& samples, const CraterList& craters, const CraterS
                     indexed = true;
                 }
                 if (kernelIndex) {
-                    FitDatumsWithKernel(prepared, {k}, sampling.ground, *kernelIndex, options,
-                                        Backend::Cpu, 1);
+                    FitDatumsWithKernel(prepared, {k}, sampling.ground, sampling.groundBatch,
+                                        *kernelIndex, options, Backend::Cpu, 1);
                     return prepared[k].datum;
                 }
             }

{terraingenpy-0.1.1.dev20 → terraingenpy-0.1.1.dev23}/terraingen/layers/craters/shaping/apply.h

@@ -33,6 +33,8 @@ struct CraterSampling {
     /// The ground datums are fitted to; empty for the raster as passed in, interpolated
     /// bilinearly.
     HeightSampler ground{};
+    /// `ground` at many points in one pass, to the same values; empty reads them one at a time.
+    HeightsSampler groundBatch{};
     /// Changes each crater's outline after its irregularity, such as secondaries stretched toward
     /// their primary; empty leaves outlines as they are. Must be deterministic and thread-safe.
     std::function<void(const Crater&, CraterOutline&)> reshape{};

{terraingenpy-0.1.1.dev20 → terraingenpy-0.1.1.dev23}/terraingen/layers/ground.h

@@ -13,6 +13,10 @@ namespace terraingen {
 /// Heights of the ground at world positions, NaN where there is none; thread-safe.
 using HeightSampler = std::function<float(double x, double y)>;
 
+/// Heights of the ground at many world positions at once, into a span of the same size;
+/// thread-safe.
+using HeightsSampler = std::function<void(std::span<const Vec2d> points, std::span<float> heights)>;
+
 /// The terrain beneath a layer (its source and the layers before it), readable anywhere.
 ///
 /// Layers that depend on the shape of the ground, such as craters cut to a datum, read it here
@@ -39,6 +43,13 @@ class Ground {
     HeightSampler Sampler(double spacing) const {
         return [this, spacing](double x, double y) { return HeightAt(x, y, spacing); };
     }
+
+    /// A sampler reading `HeightsAt` at a fixed spacing; `*this` must outlive it.
+    HeightsSampler BatchSampler(double spacing) const {
+        return [this, spacing](std::span<const Vec2d> points, std::span<float> heights) {
+            HeightsAt(points, heights, spacing);
+        };
+    }
 };
 
 }  // namespace terraingen

{terraingenpy-0.1.1.dev20 → terraingenpy-0.1.1.dev23}/terraingen/pipeline/terrain.cpp

@@ -7,9 +7,12 @@
 
 #include <algorithm>
 #include <cmath>
+#include <cstdint>
 #include <memory>
 #include <optional>
 #include <stdexcept>
+#include <utility>
+#include <vector>
 
 namespace terraingen {
 
@@ -29,6 +32,60 @@ void EvaluateStack(const Terrain& terrain, std::size_t layers, std::span<const V
     }
 }
 
+/// The Morton code of `point` on a 2^16 lattice over `bounds`.
+std::uint32_t MortonKey(const Vec2d& point, const Bounds2d& bounds) {
+    const auto quantize = [](double value, double low, double high) {
+        const double share = high > low ? (value - low) / (high - low) : 0.0;
+        return static_cast<std::uint32_t>(std::clamp(share, 0.0, 1.0) * 65535.0);
+    };
+    const auto spread = [](std::uint32_t v) {
+        v = (v | (v << 8u)) & 0x00FF00FFu;
+        v = (v | (v << 4u)) & 0x0F0F0F0Fu;
+        v = (v | (v << 2u)) & 0x33333333u;
+        v = (v | (v << 1u)) & 0x55555555u;
+        return v;
+    };
+    return spread(quantize(point.x, bounds.minX, bounds.maxX)) |
+           (spread(quantize(point.y, bounds.minY, bounds.maxY)) << 1u);
+}
+
+/// `EvaluateStack` over `points` in batches on `threads` threads, the points taken in Morton order
+/// so each batch covers a small area and prepares only the features there.
+void EvaluateBatched(const Terrain& terrain, std::size_t layers, std::span<const Vec2d> points,
+                     std::span<float> heights, double spacing, unsigned threads) {
+    constexpr std::size_t kBatch = 256;
+    if (points.size() <= kBatch) {
+        EvaluateStack(terrain, layers, points, heights, spacing);
+        return;
+    }
+    Bounds2d bounds{points[0].x, points[0].y, points[0].x, points[0].y};
+    for (const Vec2d& p : points) {
+        bounds = {std::fmin(bounds.minX, p.x), std::fmin(bounds.minY, p.y),
+                  std::fmax(bounds.maxX, p.x), std::fmax(bounds.maxY, p.y)};
+    }
+    std::vector<std::pair<std::uint32_t, std::size_t>> order(points.size());
+    for (std::size_t i = 0; i < points.size(); ++i) {
+        order[i] = {MortonKey(points[i], bounds), i};
+    }
+    std::sort(order.begin(), order.end());
+    std::vector<Vec2d> sorted(points.size());
+    for (std::size_t i = 0; i < points.size(); ++i) {
+        sorted[i] = points[order[i].second];
+    }
+    std::vector<float> values(points.size());
+    EvaluationCache cache;
+    const std::size_t batches = (points.size() + kBatch - 1) / kBatch;
+    ParallelFor(batches, threads, [&](std::size_t batch) {
+        const std::size_t begin = batch * kBatch;
+        const std::size_t count = std::min(kBatch, points.size() - begin);
+        EvaluateStack(terrain, layers, std::span<const Vec2d>(sorted).subspan(begin, count),
+                      std::span<float>(values).subspan(begin, count), spacing, &cache);
+    });
+    for (std::size_t i = 0; i < points.size(); ++i) {
+        heights[order[i].second] = values[i];
+    }
+}
+
 }  // namespace
 
 Raster<float> Evaluate(const Terrain& terrain, const RasterGrid& grid, double spacing) {
@@ -68,20 +125,8 @@ std::vector<float> EvaluatePoints(const Terrain& terrain, std::span<const Vec2d>
                                   double spacing, unsigned threads) {
     ValidateTerrain(terrain);
     RequirePositive(spacing, "Sample spacing");
-    constexpr std::size_t kBatch = 256;
     std::vector<float> heights(points.size());
-    const std::size_t batches = (points.size() + kBatch - 1) / kBatch;
-    std::optional<EvaluationCache> cache;
-    if (batches > 1) {
-        cache.emplace();
-    }
-    ParallelFor(batches, threads, [&](std::size_t batch) {
-        const std::size_t begin = batch * kBatch;
-        const std::size_t count = std::min(kBatch, points.size() - begin);
-        EvaluateStack(terrain, terrain.layers.size(), points.subspan(begin, count),
-                      std::span<float>(heights).subspan(begin, count), spacing,
-                      cache ? &*cache : nullptr);
-    });
+    EvaluateBatched(terrain, terrain.layers.size(), points, heights, spacing, threads);
     return heights;
 }
 
@@ -106,18 +151,7 @@ float TerrainGround::HeightAt(double x, double y, double spacing) const {
 
 void TerrainGround::HeightsAt(std::span<const Vec2d> points, std::span<float> heights,
                               double spacing) const {
-    constexpr std::size_t kBatch = 256;
-    const std::size_t batches = (points.size() + kBatch - 1) / kBatch;
-    std::optional<EvaluationCache> cache;
-    if (batches > 1) {
-        cache.emplace();
-    }
-    ParallelFor(batches, 0, [&](std::size_t batch) {
-        const std::size_t begin = batch * kBatch;
-        const std::size_t count = std::min(kBatch, points.size() - begin);
-        EvaluateStack(terrain_, layers_, points.subspan(begin, count),
-                      heights.subspan(begin, count), spacing, cache ? &*cache : nullptr);
-    });
+    EvaluateBatched(terrain_, layers_, points, heights, spacing, 0);
 }
 
 namespace {

{terraingenpy-0.1.1.dev20 → terraingenpy-0.1.1.dev23}/tests/unit/layers/craters/shaping/slope_test.cpp

@@ -2,8 +2,12 @@
 
 #include <gtest/gtest.h>
 
+#include <atomic>
 #include <cmath>
+#include <cstdint>
+#include <memory>
 #include <numbers>
+#include <span>
 #include <stdexcept>
 #include <vector>
 
@@ -257,3 +261,45 @@ TEST(ApplyCraters, FitsDatumsToTheSlopeShapedReliefSoNoCraterStandsAsAMesa) {
     EXPECT_LT(inside, 0.0) << "the small crater is a hollow in the shifted floor, not a mesa";
     EXPECT_LT(around, 0.4) << "and leaves its surroundings much as they are";
 }
+
+TEST(ApplyCraters, ReadsTheGroundBeneathInBatchesToTheSameHeights) {
+    const terraingen::CraterShapeModels models{
+        std::make_shared<terraingen::FassettThomsonProfile>(),
+        std::make_shared<terraingen::NoDegradation>(terraingen::LunarFreshCraterMorphometry)};
+    terraingen::Raster<float> base(121, 121, 0.0f);
+    base.SetTransform(terraingen::GeoTransform::NorthUp(-60.5, 60.5, 1.0));
+    terraingen::CraterList craters;
+    for (std::uint32_t n = 0; n < 12; ++n) {
+        craters.Append({-40.0 + 7.0 * n, 30.0 - 5.0 * n, 6.0 + n, 0.1, n + 1});
+    }
+    terraingen::CraterApplyOptions options;
+    options.datum = terraingen::CraterDatum::Plane;
+    options.slope = Enabled(0.15);
+    const auto height = [](double x, double y) {
+        return static_cast<float>(0.3 * x + 0.002 * y * y);
+    };
+    std::atomic<int> singles = 0;
+    std::atomic<int> batches = 0;
+    terraingen::CraterSampling single;
+    single.ground = height;
+    terraingen::CraterSampling batched;
+    batched.ground = [&](double x, double y) {
+        ++singles;
+        return height(x, y);
+    };
+    batched.groundBatch = [&](std::span<const Vec2d> points, std::span<float> heights) {
+        ++batches;
+        for (std::size_t i = 0; i < points.size(); ++i) {
+            heights[i] = height(points[i].x, points[i].y);
+        }
+    };
+    terraingen::Raster<float> one = base;
+    terraingen::ApplyCraters(one, craters, models, options, single);
+    terraingen::Raster<float> many = base;
+    terraingen::ApplyCraters(many, craters, models, options, batched);
+    EXPECT_EQ(singles.load(), 0) << "slopes and datums read in batches";
+    EXPECT_EQ(batches.load(), 2) << "one for the slopes, one for the datums";
+    for (std::size_t i = 0; i < one.Size(); ++i) {
+        ASSERT_EQ(one.Values()[i], many.Values()[i]);
+    }
+}

{terraingenpy-0.1.1.dev20 → terraingenpy-0.1.1.dev23}/tests/unit/pipeline/terrain_test.cpp

@@ -353,3 +353,15 @@ TEST(SharedGround, OutlivesTheTerrainItWasMadeFrom) {
     EXPECT_EQ(heights[0], expected);
     EXPECT_THROW(terraingen::SharedGround(Rolling(), 99), std::invalid_argument);
 }
+
+TEST(EvaluatePoints, GivesEachPointItsOwnHeightInAnyOrder) {
+    const Terrain terrain = Rolling();
+    std::vector<terraingen::Vec2d> points;
+    for (int n = 0; n < 700; ++n) {
+        points.push_back({std::fmod(n * 37.77, 90.0) - 45.0, std::fmod(n * 91.13, 90.0) - 45.0});
+    }
+    const std::vector<float> heights = terraingen::EvaluatePoints(terrain, points, 1.0, 3);
+    for (std::size_t n = 0; n < points.size(); n += 23) {
+        ASSERT_EQ(heights[n], terraingen::EvaluateAt(terrain, points[n].x, points[n].y, 1.0)) << n;
+    }
+}

terraingenpy-0.1.1.dev20/assets/textures/README.md

@@ -1,10 +0,0 @@
-# Textures
-
-Tileable detail textures for terrain materials, stored in Git LFS.
-
-| Files | Source | License |
-| --- | --- | --- |
-| `moon_01_diff_4k.jpg`, `moon_01_nor_gl_4k.exr`, `moon_01_rough_4k.exr`, `moon_01_disp_4k.png` | Poly Haven, "Moon 01" by Greg Zaal, Rico Cilliers and Jenelle van Heerden (photography) and Dario Barresi (processing), <https://polyhaven.com/a/moon_01> | CC0 1.0 |
-
-The moon_01 scan covers about 3.1 m of lunar regolith per tile: diffuse colour (sRGB), OpenGL
-normal map, roughness and displacement, at 4096 x 4096.