terraingenpy 0.1.0.dev283__tar.gz → 0.1.1.dev6__tar.gz

terraingenpy-0.1.1.dev6/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-18
+
+Initial release.
+
+### Added
+
+- C++20 library with Python bindings (`terraingenpy` on PyPI) for generating terrain from scratch or adding detail to existing DEMs.
+- Craters and boulders from published size-frequency distributions, with crater ages, profiles, degradation, irregularity, secondaries and ejecta.
+- Procedural 3D boulder models, and small boulders baked into the heightmap.
+- Synthetic albedo with crater ejecta and rays that fade with age.
+- Geologic features: dunes and ripples, layered strata, fractured bedrock, ventifacts and sand pooled in lows or behind boulders.
+- Planes, spheres and ellipsoids, whole-body meshes, tiles and point queries.
+- Deterministic output for a seed on any grid, tile or thread count.
+- GPU acceleration on Vulkan, CUDA and Metal, detected at run time.
+- `terraingen` command-line interface driven by JSON configurations.
+- Examples in C++, Python and JSON.
+- Release archives for Linux, macOS and Windows, Debian packages, and a Docker image.
+
+[Unreleased]: https://github.com/alexmaietta/terraingen/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/alexmaietta/terraingen/releases/tag/v0.1.0

{terraingenpy-0.1.0.dev283 → terraingenpy-0.1.1.dev6}/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.0.dev283")
+set(TERRAINGEN_FULL_VERSION "0.1.1.dev6")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" TERRAINGEN_VERSION "${TERRAINGEN_FULL_VERSION}")
 
 project(

{terraingenpy-0.1.0.dev283 → terraingenpy-0.1.1.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: terraingenpy
-Version: 0.1.0.dev283
+Version: 0.1.1.dev6
 Summary: Scientific terrain generation for planetary surfaces
 Keywords: terrain,moon,mars,craters,planetary science,simulation
 Author: Alex Maietta

{terraingenpy-0.1.0.dev283 → terraingenpy-0.1.1.dev6}/cmake/TerrainGenSlang.cmake

@@ -73,24 +73,17 @@ function(terraingen_add_slang_kernel target symbol source)
         spirv_1_3)
 endfunction()
 
-# terraingen_add_kernel(<target> <symbol> <type> <header>): compiles the kernel terraingen::<type>
-# for every GPU backend the build supports and defines `CompiledKernel<type>()` in <target>. <header>,
-# relative to the repository root, is a kernel header (see util/portable.h) declaring the plain
-# struct <type>, `float ApplyCell(<type> kernel, float height, CellPosition position)` and the
-# `CompiledKernel` specialization; the generated entry point (cmake/Kernel.slang.in) applies it to grid
-# cells for RunKernel. A form the build cannot make is embedded empty. TEMPLATE names another
-# entry point, for kernels that bind more buffers (cmake/CraterKernel.slang.in).
-function(terraingen_add_kernel target symbol type header)
-    cmake_parse_arguments(PARSE_ARGV 4 ARG "" "TEMPLATE" "")
-    if(NOT ARG_TEMPLATE)
-        set(ARG_TEMPLATE "${PROJECT_SOURCE_DIR}/cmake/Kernel.slang.in")
-    endif()
+# terraingen_add_kernel(<target> <symbol> <type> <header> <source>): compiles the Slang compute
+# kernel <source> (entry point "main", including terraingen/gpu/kernel.slang) for every GPU backend
+# the build supports and defines `CompiledKernel<type>()` in <target>. <header>, relative to the
+# repository root, is the kernel header (see util/portable.h) declaring the plain struct <type>
+# that <source> binds and the `CompiledKernel` specialization. A form the build cannot make is
+# embedded empty.
+function(terraingen_add_kernel target symbol type header source)
     set(KERNEL_TYPE "${type}")
     set(KERNEL_HEADER "${header}")
     set(KERNEL_SYMBOL "${symbol}")
     set(directory "${CMAKE_CURRENT_BINARY_DIR}/kernels")
-    set(source "${directory}/${symbol}.slang")
-    configure_file("${ARG_TEMPLATE}" "${source}" @ONLY)
     configure_file("${PROJECT_SOURCE_DIR}/cmake/Kernel.cpp.in" "${directory}/${symbol}_program.cpp"
                    @ONLY)
     target_sources(${target} PRIVATE "${directory}/${symbol}_program.cpp")

{terraingenpy-0.1.0.dev283 → terraingenpy-0.1.1.dev6}/terraingen/gpu/kernel.cpp

@@ -24,7 +24,7 @@ constexpr std::size_t kGroupSide = 16;
 /// Most workgroups Vulkan guarantees in one dimension of a dispatch; CUDA and Metal allow more.
 constexpr std::size_t kMaxGroups = 65535;
 
-/// The push constants of kernels (`cmake/Kernel.slang.in`).
+/// The push constants of kernels (`terraingen/gpu/kernel.slang`).
 struct KernelParams {
     std::uint32_t width = 0;
     std::uint32_t rows = 0;

terraingenpy-0.1.1.dev6/terraingen/gpu/kernel.slang

@@ -0,0 +1,37 @@
+// What every TerrainGen compute kernel binds first: the grid strip's heights and its column and
+// row positions, and the layout of the push constants of RunKernel (terraingen/gpu/kernel.cpp).
+// Kernel sources include this, bind their kernel struct at 3 and any extra buffers from 4 on, and
+// declare `params` after every buffer: Metal numbers buffers in declaration order and RunKernel
+// passes the push constants after the last one.
+
+[[vk::binding(0, 0)]] RWStructuredBuffer<float> heights;
+[[vk::binding(1, 0)]] StructuredBuffer<float> xs;
+[[vk::binding(2, 0)]] StructuredBuffer<float> ys;
+
+struct Params {
+    uint width;
+    uint rows;
+    uint noData;
+    float noDataValue;
+    uint firstRow;
+};
+
+namespace terraingen {
+
+static const uint kNoDataNone = 0u;
+static const uint kNoDataNan = 1u;
+
+/// Whether the thread `id` falls inside the strip.
+bool InStrip(Params params, uint3 id) {
+    return id.x < params.width && id.y < params.rows;
+}
+
+/// Whether `height` is the grid's no-data value, which kernels leave as it is.
+bool IsNoData(Params params, float height) {
+    if (params.noData == kNoDataNan) {
+        return isnan(height);
+    }
+    return params.noData != kNoDataNone && height == params.noDataValue;
+}
+
+}  // namespace terraingen

{terraingenpy-0.1.0.dev283 → terraingenpy-0.1.1.dev6}/terraingen/layers/CMakeLists.txt

@@ -58,8 +58,8 @@ terraingen_add_library(
     terraingen_sources
     terraingen_util)
 terraingen_add_kernel(terraingen_layers terraingen_kernel_noise_relief NoiseReliefKernel
-                      terraingen/layers/kernels/noise_relief.h)
-terraingen_add_kernel(
-    terraingen_layers terraingen_kernel_craters CraterShapeKernel
-    terraingen/layers/kernels/craters.h TEMPLATE
-    "${PROJECT_SOURCE_DIR}/cmake/CraterKernel.slang.in")
+                      terraingen/layers/kernels/noise_relief.h kernels/noise_relief.slang)
+terraingen_add_kernel(terraingen_layers terraingen_kernel_craters CraterShapeKernel
+                      terraingen/layers/kernels/craters.h kernels/craters.slang)
+terraingen_add_kernel(terraingen_layers terraingen_kernel_crater_datums CraterDatumKernel
+                      terraingen/layers/kernels/craters.h kernels/crater_datums.slang)

{terraingenpy-0.1.0.dev283 → terraingenpy-0.1.1.dev6}/terraingen/layers/craters/shaping/apply.cpp

@@ -13,7 +13,9 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
+#include <cstdint>
 #include <limits>
+#include <map>
 #include <numbers>
 #include <optional>
 #include <stdexcept>
@@ -181,11 +183,227 @@ Bounds2d Footprint(const PreparedCrater& prepared, double reachRadii, const Surf
     return surface.Expand({crater.x, crater.y, crater.x, crater.y}, reach);
 }
 
+/// Craters indexed for `KernelDatumRelief`, with the kernel that reads them.
+///
+/// Records hold each crater's position as the float nearest it and `lows` what that float drops,
+/// so the kernel takes differences between nearby craters exactly; bands and cells are at absolute
+/// positions. The relief summed at a point therefore depends only on the craters reaching it, not
+/// on which others an index holds, and grids and points fit the same datums.
+struct DatumKernelIndex {
+    CraterDatumKernel kernel;
+    CraterKernelBatch batch;
+    std::vector<float> lows;
+    /// Per size band: its cell size, which is its largest reach, and its first cell's column and
+    /// row.
+    std::vector<float> bandFloats;
+    /// Per size band: its cells across and down and its first cell.
+    std::vector<std::uint32_t> bandCells;
+    /// Per cell: its first entry and its entry count.
+    std::vector<std::uint32_t> cells;
+    /// Indices into the records, ascending within each cell.
+    std::vector<std::uint32_t> entries;
+    /// The record of each prepared crater, for the craters indexed.
+    std::vector<std::uint32_t> slot;
+};
+
+/// Most cells `IndexDatumRelief` lays out, and the largest cell column or row a float holds
+/// exactly enough, before datums are left to the double path.
+constexpr std::size_t kMaxReliefCells = std::size_t{1} << 24;
+constexpr float kMaxReliefCellIndex = 8388608.0f;
+
+/// The size band of `crater`: its diameter stretched by its outline, as a power of two.
+int ReliefBand(const PreparedCrater& crater) {
+    return std::ilogb(crater.crater.diameter * crater.outline.MaxScale());
+}
+
+/// Indexes the craters of `prepared` that can reach the datum footprint of any of `fitted`, in
+/// size bands of cells as wide as each band's largest reach; nothing for craters spread too far.
+std::optional<DatumKernelIndex> IndexDatumRelief(const std::vector<PreparedCrater>& prepared,
+                                                 const std::vector<std::size_t>& fitted,
+                                                 const CraterProfile& profile,
+                                                 const CraterShapeKernel& shape,
+                                                 const CraterApplyOptions& options) {
+    constexpr double kInfinity = std::numeric_limits<double>::infinity();
+    Bounds2d region{kInfinity, kInfinity, -kInfinity, -kInfinity};
+    std::vector<bool> isFitted(prepared.size(), false);
+    for (const std::size_t k : fitted) {
+        const Crater& c = prepared[k].crater;
+        const double fitRadius = options.datumFitRadii * 0.5 * c.diameter;
+        region = {std::fmin(region.minX, c.x - fitRadius), std::fmin(region.minY, c.y - fitRadius),
+                  std::fmax(region.maxX, c.x + fitRadius), std::fmax(region.maxY, c.y + fitRadius)};
+        isFitted[k] = true;
+    }
+    const std::size_t last = *std::max_element(fitted.begin(), fitted.end());
+    DatumKernelIndex index;
+    index.slot.assign(prepared.size(), 0);
+    std::vector<std::size_t> kept;
+    for (std::size_t n = 0; n <= last; ++n) {
+        const PreparedCrater& p = prepared[n];
+        const double reach = p.outline.MaxScale() * profile.ReachRadii() * 0.5 * p.crater.diameter;
+        if (isFitted[n] || (p.crater.x + reach > region.minX && p.crater.x - reach < region.maxX &&
+                            p.crater.y + reach > region.minY && p.crater.y - reach < region.maxY)) {
+            index.slot[n] = static_cast<std::uint32_t>(kept.size());
+            kept.push_back(n);
+        }
+    }
+    index.batch = MakeCraterKernelBatch(shape, profile, prepared, kept, options);
+    if (index.batch.data.empty()) {
+        index.batch.data.push_back(0.0f);
+    }
+    index.lows.resize(2 * kept.size());
+    std::map<int, std::vector<std::uint32_t>> bands;
+    for (std::size_t m = 0; m < kept.size(); ++m) {
+        const Crater& c = prepared[kept[m]].crater;
+        CraterRecord& record = index.batch.records[m];
+        record.x = static_cast<float>(c.x);
+        record.y = static_cast<float>(c.y);
+        index.lows[2 * m] = static_cast<float>(c.x - static_cast<double>(record.x));
+        index.lows[2 * m + 1] = static_cast<float>(c.y - static_cast<double>(record.y));
+        bands[ReliefBand(prepared[kept[m]])].push_back(static_cast<std::uint32_t>(m));
+    }
+    std::vector<std::uint32_t> cellOf;
+    std::vector<std::uint32_t> filled;
+    for (const auto& [band, members] : bands) {
+        const auto size = static_cast<float>(1.0001 * profile.ReachRadii() * std::ldexp(1.0, band));
+        float minI = std::numeric_limits<float>::infinity();
+        float minJ = minI;
+        float maxI = -minI;
+        float maxJ = -minI;
+        for (const std::uint32_t m : members) {
+            const float i = std::floor(index.batch.records[m].x / size);
+            const float j = std::floor(index.batch.records[m].y / size);
+            minI = std::fmin(minI, i);
+            minJ = std::fmin(minJ, j);
+            maxI = std::fmax(maxI, i);
+            maxJ = std::fmax(maxJ, j);
+        }
+        const std::size_t first = index.cells.size() / 2;
+        const auto across = static_cast<std::size_t>(maxI - minI) + 1;
+        const auto down = static_cast<std::size_t>(maxJ - minJ) + 1;
+        if (std::fmax(std::fabs(minI), std::fabs(maxI)) >= kMaxReliefCellIndex ||
+            std::fmax(std::fabs(minJ), std::fabs(maxJ)) >= kMaxReliefCellIndex ||
+            first + across * down > kMaxReliefCells) {
+            return std::nullopt;
+        }
+        index.bandFloats.insert(index.bandFloats.end(), {size, minI, minJ});
+        index.bandCells.insert(index.bandCells.end(), {static_cast<std::uint32_t>(across),
+                                                       static_cast<std::uint32_t>(down),
+                                                       static_cast<std::uint32_t>(first)});
+        index.cells.resize(2 * (first + across * down), 0);
+        cellOf.resize(members.size());
+        for (std::size_t m = 0; m < members.size(); ++m) {
+            const CraterRecord& r = index.batch.records[members[m]];
+            const auto i = static_cast<std::size_t>(std::floor(r.x / size) - minI);
+            const auto j = static_cast<std::size_t>(std::floor(r.y / size) - minJ);
+            cellOf[m] = static_cast<std::uint32_t>(first + j * across + i);
+            ++index.cells[2 * cellOf[m] + 1];
+        }
+        auto start = static_cast<std::uint32_t>(index.entries.size());
+        for (std::size_t cell = first; cell < first + across * down; ++cell) {
+            index.cells[2 * cell] = start;
+            start += index.cells[2 * cell + 1];
+        }
+        index.entries.resize(start);
+        filled.assign(across * down, 0);
+        for (std::size_t m = 0; m < members.size(); ++m) {
+            const std::uint32_t cell = cellOf[m];
+            index.entries[index.cells[2 * cell] + filled[cell - first]++] = members[m];
+        }
+    }
+    index.kernel.shape = shape;
+    index.kernel.fitRadii = static_cast<float>(options.datumFitRadii);
+    index.kernel.latticeSide = static_cast<std::uint32_t>(kDatumLatticeSide);
+    index.kernel.bandCount = static_cast<std::uint32_t>(bands.size());
+    return index;
+}
+
+/// 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
+/// `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) {
+    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);
+    const auto forEachPoint = [&](std::size_t n, const auto& visit) {
+        const double fitRadius = options.datumFitRadii * 0.5 * prepared[fitted[n]].crater.diameter;
+        for (int j = 0; j < kDatumLatticeSide; ++j) {
+            const double dy = DatumLatticeOffset(j, fitRadius);
+            for (int i = 0; i < kDatumLatticeSide; ++i) {
+                const double dx = DatumLatticeOffset(i, fitRadius);
+                if (dx * dx + dy * dy < fitRadius * fitRadius) {
+                    visit(n * kPoints + static_cast<std::size_t>(j * kDatumLatticeSide + i), dx,
+                          dy);
+                }
+            }
+        }
+    };
+    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;
+            }
+        });
+    });
+    std::vector<std::uint32_t> targets(fitted.size());
+    for (std::size_t n = 0; n < fitted.size(); ++n) {
+        targets[n] = index.slot[fitted[n]];
+    }
+    const CraterKernelBatch& batch = index.batch;
+    const std::array<KernelBuffer, 8> extra{
+        KernelBuffer{std::as_bytes(std::span(batch.records)), batch.records.size()},
+        KernelBuffer{std::as_bytes(std::span(batch.data)), batch.data.size()},
+        KernelBuffer{std::as_bytes(std::span(index.lows)), index.lows.size()},
+        KernelBuffer{std::as_bytes(std::span(index.bandFloats)), index.bandFloats.size()},
+        KernelBuffer{std::as_bytes(std::span(index.bandCells)), index.bandCells.size()},
+        KernelBuffer{std::as_bytes(std::span(index.cells)), index.cells.size()},
+        KernelBuffer{std::as_bytes(std::span(index.entries)), index.entries.size()},
+        KernelBuffer{std::as_bytes(std::span(targets)), targets.size()}};
+    Backend ran = backend;
+    if (!RunKernel(backend, CompiledKernel<CraterDatumKernel>(),
+                   std::as_bytes(std::span(&index.kernel, 1)), lattice, {0.0, 0.0}, extra)) {
+        ran = Backend::Cpu;
+        ParallelFor(fitted.size(), threads, [&](std::size_t n) {
+            for (std::size_t point = 0; point < kPoints; ++point) {
+                const std::size_t at = n * kPoints + point;
+                if (valid[at] != 0) {
+                    lattice.Values()[at] += KernelDatumRelief(
+                        index.kernel, batch.Data(), batch.records.data(), index.lows.data(),
+                        index.bandFloats.data(), index.bandCells.data(), index.cells.data(),
+                        index.entries.data(), targets[n], static_cast<std::uint32_t>(point));
+                }
+            }
+        });
+    }
+    ParallelFor(fitted.size(), threads, [&](std::size_t n) {
+        PlaneFit fit;
+        forEachPoint(n, [&](std::size_t at, double dx, double dy) {
+            if (valid[at] != 0) {
+                fit.Add(dx, dy, lattice.Values()[at]);
+            }
+        });
+        std::optional<Plane>& datum = prepared[fitted[n]].datum;
+        if (fit.Empty()) {
+            datum.reset();
+        } else {
+            datum = options.datum == CraterDatum::Plane ? fit.Solve() : Plane{fit.Mean(), 0.0, 0.0};
+        }
+    });
+    LogDebug("craters", "Fitted ", fitted.size(), " crater datums on ", BackendName(ran));
+}
+
 /// Fits the datums of craters `fitted` of `prepared` to `ground`, or to the raster as given when
-/// it is empty.
+/// it is empty; with the crater datum kernel when `shape` is set and it can take them.
 void FitDatums(std::vector<PreparedCrater>& prepared, const std::vector<std::size_t>& fitted,
                const Raster<float>& raster, const CraterProfile& profile,
-               const CraterApplyOptions& options, const CraterSampling& sampling) {
+               const std::optional<CraterShapeKernel>& shape, const CraterApplyOptions& options,
+               const CraterSampling& sampling) {
     std::optional<Raster<float>> input;
     HeightSampler ground = sampling.ground;
     if (!ground) {
@@ -195,6 +413,14 @@ void FitDatums(std::vector<PreparedCrater>& prepared, const std::vector<std::siz
                 Sample(*input, x, y).value_or(std::numeric_limits<double>::quiet_NaN()));
         };
     }
+    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);
+            return;
+        }
+    }
     const CraterReliefIndex index(prepared, profile, MaxOutlineScale(options.irregularity),
                                   options.surface);
     ParallelFor(fitted.size(), sampling.threads, [&](std::size_t n) {
@@ -419,10 +645,11 @@ void ApplyCraters(Raster<float>& raster, const CraterList& craters, const Crater
             windows.push_back(std::move(around));
         }
     }
+    const std::optional<CraterShapeKernel> kernel = MakeCraterShapeKernel(profile, options);
     if (options.datum != CraterDatum::None && !onRaster.empty()) {
-        FitDatums(prepared, onRaster, raster, profile, options, sampling);
+        FitDatums(prepared, onRaster, raster, profile, kernel, options, sampling);
     }
-    if (const std::optional<CraterShapeKernel> kernel = MakeCraterShapeKernel(profile, options)) {
+    if (kernel) {
         CraterKernelBatch batch =
             MakeCraterKernelBatch(*kernel, profile, prepared, onRaster, options);
         if (!ShapeTilesOnGpu(raster, sampling.backend, *kernel, batch, prepared, onRaster,
@@ -467,32 +694,45 @@ void ApplyCraters(SampleBlock& samples, const CraterList& craters, const CraterS
         PrepareCraters(craters, options, sampling.spacing, *models.degradation, sampling.reshape);
     const std::vector<ReachingCrater> reaching =
         CratersReaching(samples, prepared, CraterReachRadii(profile, options), options.surface);
+    const std::optional<CraterShapeKernel> kernel = MakeCraterShapeKernel(profile, options);
+    std::vector<std::size_t> indices;
+    for (const ReachingCrater& crater : reaching) {
+        indices.push_back(static_cast<std::size_t>(crater.prepared - prepared.data()));
+    }
     if (options.datum != CraterDatum::None && !reaching.empty()) {
+        std::optional<DatumKernelIndex> kernelIndex;
+        bool indexed = false;
         std::optional<CraterReliefIndex> index;
-        const auto fit = [&](const ReachingCrater& crater) {
+        const auto fit = [&](std::size_t k) -> std::optional<Plane> {
+            if (kernel && options.datum != CraterDatum::CentreHeight) {
+                if (!indexed) {
+                    kernelIndex = IndexDatumRelief(prepared, indices, profile, *kernel, options);
+                    indexed = true;
+                }
+                if (kernelIndex) {
+                    FitDatumsWithKernel(prepared, {k}, sampling.ground, *kernelIndex, options,
+                                        Backend::Cpu, 1);
+                    return prepared[k].datum;
+                }
+            }
             if (!index) {
                 index.emplace(prepared, profile, MaxOutlineScale(options.irregularity),
                               options.surface);
             }
-            const auto k = static_cast<std::size_t>(crater.prepared - prepared.data());
-            return FitCraterDatum(crater.prepared->crater, options,
+            return FitCraterDatum(prepared[k].crater, options,
                                   DatumGround(sampling.ground, *index, k));
         };
-        for (const ReachingCrater& crater : reaching) {
+        for (const std::size_t k : indices) {
             if (sampling.cache != nullptr) {
-                crater.prepared->datum = *sampling.cache->Get<std::optional<Plane>>(
-                    sampling.owner, crater.prepared->crater.id, sampling.spacing,
-                    [&] { return fit(crater); });
+                prepared[k].datum = *sampling.cache->Get<std::optional<Plane>>(
+                    sampling.owner, prepared[k].crater.id, sampling.spacing,
+                    [&] { return fit(k); });
             } else {
-                crater.prepared->datum = fit(crater);
+                prepared[k].datum = fit(k);
             }
         }
     }
-    if (const std::optional<CraterShapeKernel> kernel = MakeCraterShapeKernel(profile, options)) {
-        std::vector<std::size_t> indices;
-        for (const ReachingCrater& crater : reaching) {
-            indices.push_back(static_cast<std::size_t>(crater.prepared - prepared.data()));
-        }
+    if (kernel) {
         const CraterKernelBatch batch =
             MakeCraterKernelBatch(*kernel, profile, prepared, indices, options);
         const CraterData data = batch.Data();

{terraingenpy-0.1.0.dev283 → terraingenpy-0.1.1.dev6}/terraingen/layers/craters/shaping/datum.cpp

@@ -12,9 +12,6 @@ namespace {
 
 using Matrix3 = std::array<std::array<double, 3>, 3>;
 
-/// Points per side of the lattice a crater's datum is fitted over.
-constexpr int kDatumSamples = 7;
-
 double Determinant(const Matrix3& m) {
     return m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) -
            m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) +
@@ -31,10 +28,10 @@ PlaneFit FitFootprint(const Crater& crater, double fitRadii, const Surface& surf
                       const HeightSampler& ground) {
     const double fitRadius = fitRadii * 0.5 * crater.diameter;
     PlaneFit fit;
-    for (int j = 0; j < kDatumSamples; ++j) {
-        const double dy = fitRadius * ((2.0 * j + 1.0) / kDatumSamples - 1.0);
-        for (int i = 0; i < kDatumSamples; ++i) {
-            const double dx = fitRadius * ((2.0 * i + 1.0) / kDatumSamples - 1.0);
+    for (int j = 0; j < kDatumLatticeSide; ++j) {
+        const double dy = DatumLatticeOffset(j, fitRadius);
+        for (int i = 0; i < kDatumLatticeSide; ++i) {
+            const double dx = DatumLatticeOffset(i, fitRadius);
             if (dx * dx + dy * dy >= fitRadius * fitRadius) {
                 continue;
             }

{terraingenpy-0.1.0.dev283 → terraingenpy-0.1.1.dev6}/terraingen/layers/craters/shaping/datum.h

@@ -47,6 +47,15 @@ class PlaneFit {
     double syh_ = 0.0;
 };
 
+/// Points per side of the lattice crater datums are fitted over.
+constexpr int kDatumLatticeSide = 7;
+
+/// The offset (m) from a crater's centre of lattice point `index` (0 to `kDatumLatticeSide` - 1)
+/// along one axis of a fit footprint of `fitRadius` (m).
+inline double DatumLatticeOffset(int index, double fitRadius) {
+    return fitRadius * ((2.0 * index + 1.0) / kDatumLatticeSide - 1.0);
+}
+
 /// The datum a crater is cut to, fitted to the ground beneath it; nothing for
 /// `CraterDatum::None` or where the ground has no data.
 ///

terraingenpy-0.1.1.dev6/terraingen/layers/kernels/crater_datums.slang

@@ -0,0 +1,34 @@
+// Adds, to the ground under each lattice point of each crater's datum footprint, the relief of the
+// craters applied before it (KernelDatumRelief). A row is one crater (`targets`), a column one
+// lattice point. The host side is FitDatumsWithKernel
+// (terraingen/layers/craters/shaping/apply.cpp).
+#include "terraingen/gpu/kernel.slang"
+#include "terraingen/layers/kernels/craters.h"
+
+[[vk::binding(3, 0)]] StructuredBuffer<terraingen::CraterDatumKernel> kernels;
+[[vk::binding(4, 0)]] StructuredBuffer<terraingen::CraterRecord> records;
+[[vk::binding(5, 0)]] StructuredBuffer<float> data;
+[[vk::binding(6, 0)]] StructuredBuffer<float> lows;
+[[vk::binding(7, 0)]] StructuredBuffer<float> bandFloats;
+[[vk::binding(8, 0)]] StructuredBuffer<uint> bandCells;
+[[vk::binding(9, 0)]] StructuredBuffer<uint> cells;
+[[vk::binding(10, 0)]] StructuredBuffer<uint> entries;
+// The crater of each row.
+[[vk::binding(11, 0)]] StructuredBuffer<uint> targets;
+
+// After every buffer (terraingen/gpu/kernel.slang).
+[[vk::push_constant]] ConstantBuffer<Params> params;
+
+[shader("compute")]
+[numthreads(16, 16, 1)]
+void main(uint3 id : SV_DispatchThreadID) {
+    if (!terraingen::InStrip(params, id)) {
+        return;
+    }
+    const uint at = id.y * params.width + id.x;
+    heights[at] = heights[at] + terraingen::KernelDatumRelief(kernels[0], data, records, lows,
+                                                              bandFloats, bandCells, cells,
+                                                              entries,
+                                                              targets[params.firstRow + id.y],
+                                                              id.x);
+}