Target reconciled with the map's findings: the plugin is still wired in, the July CultLib planetary line is not a consumer, and mesh edges get an identity row (edge-keyed refined points make watertightness structural). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
59 KiB
Asura: cut map
Status: cut map, Imagination pass 1, 2026-09-25. Nothing here has landed.
docs/target.md owns the ends. This document owns the means. Where this map and
the Body disagree, the Body wins and this map is stale. The map lives on main
of GameCult/Asura.
Pinned HEADs (every file:line below is against these):
| Repo | Ref | SHA | Note |
|---|---|---|---|
| Asura | main |
54a748a |
target with the one-tile-mode and crease-snapping rulings |
| CultLib | origin/main |
29e50ad |
Local main in F:\Projects\CultLib is 15 commits behind (d110d9d). The main checkout sits on hands/cultmath-erf. Work from origin/main in a worktree. |
| CultLib tags | cultmath-unity-v0.2.4 / cultlib-unity-v1.0.60 |
6d5e209 / 45c2f40 |
both are ancestors of 29e50ad |
| Aetheria | origin/master |
9b85211f |
mainline, 2026-09-17; pins cultlib-unity-v1.0.59 and cultmath-unity-v0.2.3 |
| Aetheria | origin/codex/fire-control-12 |
ab14552a |
In flight: 218 commits ahead of master and 2 ahead of the local checkout (14ee2a52). It pins cultlib 1.0.60, cultmath 0.2.4 and caching 1.4.0. Do not touch F:\Projects\Aetheria's tree. |
Rulings: the target's dated rulings, through the 2026-09-25 crease-snapping ruling. Nothing further yet.
Open: operator questions Q1–Q9 at the end. Q1 blocks Cuts 1 and 7. Q3, Q5 and Q6 block Cut 7. Q4 blocks Cut 2a's scope.
Cut order
2a CultMath gaps ─┐
2 surface nets ──┴─> 3 CultLib Unity release ─> 4a Asura skeleton ─> 4b field + sampling
─> 5a mesh + bare render ─> 5b benchmark
─> 6a tile pass ─> 6b patch render + watertight ─> 6c crease snap
─> R Asura release tag
1 delete plugin (Aetheria; any time after Q1) ─────────────────────────> 7a defs ─> 7b integration ─> 7c docked view
Re-splits from the brief, with reasons:
- 2a is new. CultMath has no fBm, no smooth-min and no cellular noise. The
HLSL function list at
29e50adis catmullrom, clamp, csum, the béziers, damp, decay, degrees, distance, frac, hash, lengthsq, lerp, pcg/pcg3d/pcg4d, reflect, rotate, saturate, the smoothsteps, snoise, step and value_noise*. The target needs fBm for its noise and smooth-min for its bevels and pads. Gaps are filled in the owner, and 2a releases before Cut 3, because Cut 3's Geometry DLL is compiled against the CultMath version it ships beside (see Cut 3). - Cut 4 is split into the skeleton (package, host project, headless Core tests) and the GPU work. Each part alone is roughly 150–200k tokens.
- Cut 5 is split into the build path and the benchmark. The benchmark has its own harness and its own committed artefact.
- Cut 6 is split three ways, as the operator asked: the compute pass, then rendering with a watertightness proof at uniform N, then crease snapping.
- R (Asura release tag) is its own cut, because a tag is a cut and gets its Soul pass before it is pushed (SKILL.md step 5).
- Cut 7 is split into definitions (headless, mutation-reachable), then render integration, then the docked view.
- Cut 1 runs whenever Q1 is settled. Nothing in Cuts 2–6 depends on it.
Standing design decisions (means, not operator forks)
These apply across cuts. Self may overrule any of them. None is a product fork.
-
D1. The quad mesh stays a plain CultLib value, not a document. The surface-nets output is
CultGeometryQuadMesh, a sealed class with no[MessagePackObject]and no[CultDocument]. It is not a struct, because a struct'sdefaultwould carry null arrays. Asura persists nothing (target identity table), so the mesh has no wire contract to keep. -
D2. Face-weighted normals belong in CultLib, beside surface nets, as a pure function of the quad mesh. Four reasons:
- The function is engine-neutral: quads in, per-vertex normals out.
- The mesher owns the topology the normals are computed over.
- It runs on the same worker thread as the mesher, so there is no extra handoff.
- In CultLib it is reachable by Stryker; in Asura it would be Unity code that no mutation tool reaches.
Unity's
Mesh.RecalculateNormalsis not a substitute, because its weighting is not the rule the operator ruled. -
D3. The field is unit-radius in body-local space. Asura's mesh is a child of Aetheria's
Bodytransform, which already carrieslocalScale = BodyRadius(ZoneRenderer.cs:406at master). This depends on the Q5 answer. -
D4. Patch points are stored once per shared element. A body's tile data is three regions, each keyed by the thing it belongs to:
- one refined point per base vertex;
E−1refined points per unique mesh edge;(N−1)²interior points per quad.
A mesh edge joins two surface-net vertices, so it is dual to one grid face. Its key is the vertex-index pair, lower index first. The patch expansion reads corners, edges and interior from these regions, so neighbouring quads read the same memory for their shared edge. Watertightness then holds by construction, not by floating-point determinism between two invocations. The same edge-keyed region carries the docked view's per-edge factor (Cut 7c). This is how invariant 5 is made impossible to violate rather than merely likely to hold.
-
D5. The atlas is per body. A body's tile storage is one
GraphicsBuffersized from its quad count and N. Its "allocation table" is the identity: slot = the quad's index in the mesher's sorted output. It is freed by disposing the buffer on unload. This satisfies the target's identity row ("quad id → slot index; freed on unload"). A shared atlas with a block allocator waits until the benchmark shows draw or buffer count is the cap. Record the decision; do not build the allocator. -
D6. Asura keeps a headless Core. Rules with no GPU in them live in a
noEngineReferencesassembly: level and N selection, the remesh/retile decision, mesh-edge derivation, the patch layout offsets and the build job body. A smallnet10.0test project compiles those sources, the wayAetheria.Sharedcompiles ServerShared. This is the only way Stryker reaches Asura. GPU rules are defended by readback checks at the layer where they fail. -
D7. Unity tests run in a host project inside the Asura repo (
unity/AsuraHost/), following CultLib's ownsrc/GameCult.Unityhost project. Aetheria's tree stays out of the loop until Cut 7.
Verification hosts (applies to every cut)
- Yggdrasil (
C:\Users\Meta\.claude\skills\eureka\tools\stopgap\ygg-verify.sh, imagedotnet) runs every .NET build, test and Stryker run: CultLib Geometry, CultMath,Asura.Core.TestsandAetheria.Shared.Tests. Example:ygg-verify.sh /f/Projects/CultLib <rev> dotnet 'dotnet tool restore && cd tests/GameCult.Geometry.Tests && dotnet test && dotnet stryker --since:<base>'. Keep the job's own exit status last; see the script's header. - The Windows workstation (Starfire) runs anything Unity, anything that needs
the GPU, and the CultLib Unity package build. The package build runs
build-quic-native.ps1, which is Windows-native. Rules for Starfire:- One job at a time.
- Run detached, with a log in the scratchpad and the PID recorded, and poll the log.
- Batchmode refuses a project that is open in the editor.
- Never pass
-nographicsto a GPU test. Unity's docs for 6000.3 say that in batch mode with-nographics"Unity doesn't initialize the graphics device". - Revert incidental asset churn after every run.
- Shader compile probe (done in this pass):
CultMath.hlslat29e50ad, included into acs_5_0kernel that sums six octaves ofcultmath_snoise(float3), compiles cleanly with FXC (Windows Kits\10\bin\10.0.26100.0\x64\fxc.exe /T cs_5_0). FXC is the compiler Unity uses for D3D11 compute. Aetheria's Windows APIs are D3D11 first, then D3D12 (ProjectSettings.asset:350,m_APIs: 0200000012000000, not automatic), and the render pipeline is Built-in (GraphicsSettings.asset:41,m_CustomRenderPipeline: {fileID: 0}). No Aetheria shader includesCultMath.hlslyet, so Asura is its first Unity compute consumer. - AsyncGPUReadback: the 6000.3 script reference states no render-pipeline
requirement.
Request(GraphicsBuffer, size, offset, callback)exists, and the docs say readback "adds a few frames of latency". Platform support is exposed only throughSystemInfo.supportsAsyncGPUReadback. That is a runtime fact, so Cut 4b asserts it on Starfire's device rather than assuming it.
Cut 1. Aetheria: delete the Celestial Body plugin (subtraction only)
- Repo/branch: Aetheria,
hands/asura-cut1, based per Q1: master9b85211f, or the merged fire-control line. Anchors are given for both; the plugin's own files are identical between master andab14552a. - First:
- A worktree. Never
F:\Projects\Aetheriaitself. - The worktree needs LFS objects for the files it edits, because
*.assetis LFS (.gitattributes);Settings.assetis a 130-byte pointer in git. Rungit lfs pull --includefor those paths. - The Unity compile check needs a full LFS checkout and a Library import. That is long. Self decides whether Hands reuses an existing Aetheria worktree.
- Record the negative-grep baselines below before any edit.
- A worktree. Never
- Deletes first:
-
Assets/Plugins/Celestial Body/: 310 files, 11,344 text lines (C# 3,221;.meta3,051;.mat1,639;.shader1,342;.cginc1,219;.compute755;.asset111, all LFS pointers;.txt6), plus binaries (6 tif, 4 psd, 3 png, 3 jpg, all LFS). AlsoAssets/Plugins/Celestial Body.meta(8 lines). -
Assets/Scripts/Zone Display/PlanetObject.cs:14: theCelestialBodyGenerator Generatorfield. -
ZoneRenderer.cs:40: theLODHandler LODHandlerfield. -
ZoneRenderer.cs:397-401: the body-settings pick. Keep:396(planet = Instantiate(Planet, ZoneRoot);) and:402, which is a comment. This pick is also a live nondeterminism: planet appearance is chosen withUnityEngine.Random, not the zone seed. It dies here and is not replaced. -
ZoneRenderer.cs:423:LODHandler.FindPlanets();. -
Assets/Scripts/Gameplay/GameSettings.cs:38, theBodySettingsCollectionsfield, and:84-89, the[Serializable] class BodySettingsCollection. Lines are for master. Onab14552athey are:34and:79-84, because settings Cut 0 landed there. -
Assets/Resources/Settings.asset:77-98(smudged): theBodySettingsCollections:block of 6 collections and 7 references, all into the plugin. Edit the text with Unity closed and commit through LFS. -
Assets/Prefabs/RPG/Planets/Planet.prefab:- the disabled generator component
--- !u!114 &-7153121627769399805(:221-240,m_Enabled: 0at:228); - its
- component:entry on GameObject&8859079004937162791; - the
Generator:line at:220.
The
Terrain Meshbody (high-res-sphere.fbxwithAssets/Materials/Planet.mat),Minimap IconandGravity Wellstay. - the disabled generator component
-
Assets/Scenes/ARPG.unity:- the enabled
LODHandlercomponent--- !u!114 &1009503736(:16782-16795); - its
- component:entry on GameObject&1009503727; - ZoneRenderer's
LODHandler: {fileID: 1009503736}at:16721.
- the enabled
-
Per Q2:
Assets/Resources/Prefabs/Stations/PlanetOutpost.prefab(+meta) andAssets/Resources/Locations/ReconStationAlpha.{prefab,asset}(+metas). What they reference:PlanetOutpost.prefab:322-332has an enabledCelestialBodyGeneratorwhosebodyisReconStationAlpha.asset, and:225uses the plugin'sWatchful Eye.mat.ReconStationAlpha.assetis itself aCelestialBodySettingsinstance (:12, script guid;:15-16reference plugin Shape and Shading assets).ReconStationAlpha.prefab:90usesWatchful Eye.mat.
No code, prefab, scene or asset references either prefab by guid. The content catalog (
GameData/Aetheria.cc) is not plain text (noAssets/Resourcesstrings survive a byte grep), so a string search cannot clear it. Hands must decode it (see verification) before deleting. If a live consumer appears, stop: that is a fork.
-
- Keeps:
- Everything else under
Assets/Plugins(GPU Noise, LowPoly_AsteroidsPack and the rest). PlanetObject.Body/GravityWell/Icon.- The gas-giant and sun branches of
LoadPlanet(:367-393). - Nothing from the plugin is harvested (ruling F2).
- Everything else under
- Authority map: subtraction only. No owner changes. Planet appearance becomes the stand-in sphere until Cut 7b.
- Verification (Starfire, one job):
- builds: a Unity batchmode compile of the worktree (no GPU needed, so
-nographicsis allowed here) with zero compile errors. Also anAetheria.Sharedheadless build on Yggdrasil. It is unaffected, but it proves ServerShared never touched the plugin. - catalog: on the fire-control line,
EngineAssetCheck.Runin batchmode (docs/addressables-cut.md:220) exits 0 after the delete. On master, a scratch decode ofGameData/Aetheria.ccthrough AetherDb's cache-open path must find 0 string fields containingPlanetOutpost,ReconStationAlphaorCelestial Body, and print the count of strings scanned. The probe stays scratch. - negative, verified against master today:
rg -n -i "celestial" Assets ProjectSettings Packages -g "!*.md"→ 0. It hits onlyGameSettings.cs:88andPlanetObject.cs:14outside the plugin now.rg -n -w "LODHandler|BodySettingsCollections?|CelestialBody\w*" Assets→ 0.TextureSizeinSlime.cs:27is an unrelated field; do not grep it.- The GUID sweep: build the list of
guid:values from the plugin's 174.metafiles at the base commit, thenrg -F -f <list> Assets ProjectSettingsover the smudged tree → 0. Today it hits 6 files:Planet.prefab:230,PlanetOutpost.prefab:225,322,ReconStationAlpha.prefab:90,ARPG.unity:16791,ReconStationAlpha.asset:12,15,16andSettings.asset:79-95. Run it on the smudged tree, becausegit grepcannot see into LFS*.assetfiles.
- operator: open ARPG, enter a zone, and see rocky planets render as the stand-in sphere with no missing-script warnings in the console.
- builds: a Unity batchmode compile of the worktree (no GPU needed, so
- Rules that lose a test: none. The plugin had no tests.
- Ledger estimate: −310 files, −11,344 text lines, −16 LFS binaries, −~15 C# lines, −~45 YAML lines. Add −2 prefabs and −1 asset if Q2 is A.
- Hands budget: ~120k tokens.
- Doc sweep for Self:
docs/settings-globals-cut.mdfork B (:527-535), which moves the 7 body-settings assets intoResources, is superseded by F2. Mark it history in that map the day this cut lands.
Cut 2a. CultMath: fBm, smooth-min (and cellular noise per Q4)
-
Repo/branch: CultLib,
hands/cultmath-asura-noise, fromorigin/main29e50ad, in its own worktree. Releasecultmath-unity-v0.3.0: additive, so a minor bump perdocs/semver-policy.md. The release belongs to this cut and gets a Soul pass before the tag. -
Adds, each in C#
math(packages/cultmath/src/CultMath/math.cs, nearsnoiseat:594) and inshaders/CultMath.hlslwith the same name prefixedcultmath_:fbm(float3 p, int octaves, float lacunarity, float gain): the octave sum ofsnoise(float3).smin(float a, float b, float k): polynomial smooth minimum. It feeds the target's brush-seam bevels and the dock pad blend.- Per Q4 = A:
cellular(float3 p), returning the nearest-feature distance, andcellular_idor an out parameter for the feature cell id. It is built onpcg3d. It is needed for craters.
Mirror bodies must stay inside the transformations listed in
packages/cultmath/docs/design.md:92. -
Keeps: everything. Both tracked copies of
CultMath.hlsl(packages/cultmath/shaders/andpackages/cultmath/unity/org.gamecult.cultmath/Shaders/) are the same blob (6179d45) and must stay identical. The existing package script already enforces this. -
Verification (Yggdrasil):
HlslSourceCompatibilityTests.EveryMirrorFunctionMatchesCSharpMathautomatically compares everycultmath_*mirror with a C# counterpart bit for bit. A new mirror with no C# twin failsAssert.Contains(... MirrorOnly).- Behavioural tests:
fbmwith 1 octave equalssnoise;- gain and lacunarity act per octave;
smin(a,b,k) ≤ min(a,b), and it equalsminwhen|a−b| ≥ k;cellulardistance is ≥ 0 and zero at a feature point, and the id is constant within a cell.
- Stryker,
-t mtp --since:29e50ad, frompackages/cultmath/tests/CultMath.Tests(xunit.v3 needsmtp, perdocs/mutation-testing.md). Triage every survivor. - Starfire: FXC
cs_5_0compile of a kernel calling each new mirror function. This is the probe above, extended; FXC is Unity's D3D11 compiler.
-
Rules that must die: octave count honoured; gain applied multiplicatively per octave;
smin's blend region bounded byk;cellularis the nearest feature, not the first one found. -
Ledger estimate: +~90 C#, +~70 HLSL, +~150 test lines.
-
Hands budget: ~150k tokens, including the release.
Cut 2. CultLib: surface nets and face-weighted normals in GameCult.Geometry
- Repo/branch: CultLib,
hands/asura-surface-nets, fromorigin/main29e50ad, in its own worktree. No release in this cut; Cut 3 releases. - Do not touch:
CultGeometryIsoSurface.cs(Extract, marching tetrahedra, unwelded,:39-101),CultGeometryDocuments.cs(includingCultGeometryTriangleMesh,:373-400) andISOSURFACE-PROVENANCE.md. - Adds, in
src/GameCult.Geometry/:-
CultGeometrySurfaceNets.Extract(float[,,] samples, float isoValue = 0f, CultVec3 origin = default, float cellSize = 1f) → CultGeometryQuadMesh. This is the same parameter list and validation asCultGeometryIsoSurface.Extract(:39-54): null, fewer than 2 samples on any axis, and a non-finite or non-positive cell size all throw the same exception types. -
CultGeometryGridEdge: a readonly struct{ int X, Y, Z; byte Axis }. It is the grid edge from sample(X,Y,Z)to(X,Y,Z)+e_Axis, which is the target's(cell, axis). It isIEquatableandIComparable, ordered by(X, Y, Z, Axis). -
CultGeometryQuadMesh, a sealed class and not a document (D1), with:Positions(float[], xyz per welded vertex);Quads(uint[], 4 vertex indices per quad);QuadEdges(CultGeometryGridEdge[], one per quad, strictly ascending);QuadCountandVertexCount.
-
CultGeometryQuadNormals.FaceWeighted(CultGeometryQuadMesh) → float[](xyz per vertex, D2). Each quad contributes its diagonal cross product(d1 × d2), whose length is twice the area of a non-planar quad, so the direction and the area weight come together. Zero-area quads contribute nothing. A vertex whose sum is zero gets a zero normal, matchingExtract's degenerate rule at:175-177. -
SURFACE-NETS-PROVENANCE.md, packed likeISOSURFACE-PROVENANCE.md(GameCult.Geometry.csprojNone Include ... Pack). It cites:- S. Gibson, "Constrained Elastic Surface Nets", MICCAI 1998 (MERL TR99-24);
- M. Lysenko, "Smooth Voxel Terrain (Part 2)", 0fps.net, 2012;
- N. Max, "Weights for Computing Vertex Normals from Facet Normals", J. Graphics Tools 4(2), 1999.
It states that the implementation is fresh and copies no code or tables. The deliberate behaviour it records:
- inside is
<= iso; - the vertex is the mean of the linearly interpolated edge crossings of its cell;
- Gibson's elastic relaxation is omitted;
- one quad is emitted per crossing interior edge;
- vertices are welded.
-
tests/GameCult.Geometry.Tests/SurfaceNetsTests.csandQuadNormalsTests.cs(NUnit, likeIsoSurfaceTests.cs). -
tests/GameCult.Geometry.Tests/stryker-config.json:"project": "GameCult.Geometry.csproj";"mutate": ["**/src/GameCult.Geometry/**/*.cs"];"mutation-level": "Standard"and the same reporters and thresholds as CultMath's (break: 0);- no
"test-runner": "mtp". This project is NUnit 4 withNUnit3TestAdapterandMicrosoft.NET.Test.Sdk, so Stryker's defaultvstestrunner applies.
-
docs/mutation-testing.md, Follow-ups: moveGameCult.Geometryfrom the unscoped list to scoped (diff-scoped only). A full-project Geometry baseline is a recorded follow-up, not this cut.
-
- Contract rules. Each gets a behavioural test, and each must die under
mutation:
-
Sign convention matches Extract. A sample
== isois inside. Fixture: the same field with one sample set to exactlyisoand toiso − εproduces identical quads.iso + εmust differ, which kills<for<=. -
Naming. A quad's
QuadEdgesentry is the grid edge whose endpoints straddle iso. Fixture: a 3×3×3 grid with one inside sample at(1,1,1)gives exactly 6 quads. Their edges are(1,1,1,a)and(1,1,1)−e_afora = 0..2. Also use a non-cubic grid (e.g. 4×3×5) with an off-centre inside blob, so axis and dimension swaps change the answer. -
Orientation. Every quad's
(d1 × d2)has a positive dot product with(outside endpoint − inside endpoint)of its edge. The single-sample fixture exercises both cases: inside at the lower end (+aedges) and inside at the upper end (−aedges). -
Vertex placement. A vertex is the mean of its cell's interpolated crossings:
- a tilted plane pins interpolation against midpoints;
- a curved-field cell whose crossings sit at unequal positions pins the mean against the first crossing;
originandcellSizeare applied, reusingExtract's determinism test shape (IsoSurfaceTests.cs:67-87).
-
Welding and closure. On a closed field (a sphere with a one-sample margin):
- every undirected quad edge is used by exactly 2 quads;
VertexCount − QuadCount == 2(Euler characteristic for genus 0).
Probed in this pass with a scratch counter over sphere grids of 8, 10, 12, 16, 32 and 64 per axis:
V − Q = 2and 0 non-manifold edges at every size. Quads come out at 72, 192, 312, 672, 3,696 and 16,968. So the operator's "couple hundred polygons" rock is a 10³–12³ grid. Assert the invariants, not these counts. On an ambiguous cell (checkerboard) the edge count is even, not 2; a test states that too, so nobody "fixes" surface nets into claiming manifoldness. -
Open boundary. An edge whose 4 surrounding cells do not all exist emits no quad. Fixture: a plane crossing the whole grid yields quads only on interior edges, and the mesh is open. This is documented, not hidden.
-
Determinism and order. Two calls give equal arrays, and
QuadEdgesis strictly ascending. Asura's slot index is the quad index (D5), so order is contract. -
Face-weighted normals:
- a large quad and a sliver sharing a vertex give a normal within ε of the large quad's;
- a closed cube-like mesh gives unit normals;
- a zero-area quad contributes nothing, and a vertex with all-zero contributions gives a finite zero vector, not NaN.
A mutant that drops the area weight (normalising each face first) must fail.
-
- Authority map:
- Owner:
GameCult.Geometryowns surface-nets topology, naming, orientation and face-weighted normals. - Inputs: a sampled grid.
- Outputs:
CultGeometryQuadMesh, plus normals on request. - Derived: nothing persisted.
- Forbidden writers: Asura must not re-derive quad naming or orientation. It consumes them.
- Owner:
- Verification (Yggdrasil):
dotnet test tests/GameCult.Geometry.Tests; paste the per-file test counts.dotnet tool restore, then fromtests/GameCult.Geometry.Testsdotnet stryker --since:29e50ad. Triage every survivor by name. Thestatic readonlycaveat indocs/mutation-testing.mdapplies to themtprunner, notvstest.- negative:
rg -n "MessagePackObject|CultDocument" src/GameCult.Geometry/CultGeometrySurfaceNets.cs src/GameCult.Geometry/CultGeometryQuadNormals.cs→ 0.
- Ledger estimate: +~220 C#, +~300 test lines, +1 provenance file, +1 Stryker config.
- Hands budget: ~200k tokens.
Cut 3. CultLib → Unity: GameCult.Geometry ships in org.gamecult.cultlib
- Repo/branch: CultLib,
hands/cultlib-unity-geometry, frommainafter Cuts 2a and 2. Releasecultlib-unity-v1.1.0: adding an assembly is additive, so a minor bump. Soul runs before the tag is pushed. - Decision (default A; Self may put it to the operator): ship
GameCult.Geometry.dllinside the existingorg.gamecult.cultlibpackage, not in a neworg.gamecult.geometry. The reasons:- Geometry depends on
GameCult.Cachingand MessagePack, which that package already ships. - The release machinery exists: the semver check, the deterministic build, the version check and the template update.
- Aetheria then gains no new UPM dependency for it.
- Geometry depends on
- Not a source: tag
gamecult-geometry-unity-v0.1.0(b65619f) and branchesorigin/codex/geometry-cultmesh-unity-releaseandorigin/codex/geometry-ownership-migration. They carry an unmerged July planetary line:Planetary*cube-sphere heightfield plus erosion,unity/org.gamecult.geometryand HLSL pages. No mainline consumes it. FensalirHEAD 58107ffreferences only CultMath, and Aetheria references neither. Do not build on it, and do not delete it; see findings. - Per-file changes against
29e50ad:scripts/build-unity-package.ps1:- add a publish of
src\GameCult.Geometry\GameCult.Geometry.csproj(netstandard2.1 viasrc/Directory.Build.props), shaped like the WebSocket publish at:77-85, with the same deterministic arguments (:65-67) and-p:CultLibPackageVersion; - add its output to
$publishedByName(:131-140); - add
"GameCult.Geometry.dll"to$expectedAssemblies(:104-130). Do not addCultMath.dll:org.gamecult.cultmathships it, and the copy loop (:149-156) copies only expected names; - after
:167-171, add a check that the packagedGameCult.Geometry.dllversion equals the package version, and that its referencedCultMathassembly version equalspackages/cultmath/unity/org.gamecult.cultmath/package.json's version (0.3.0 after 2a). This is the coupling rule: Aetheria must pin the cultmath tag Geometry was compiled against; -UpdateTemplate(:187-208) already copies every expected assembly.
- add a publish of
unity/org.gamecult.cultlib/Runtime/GameCult.CultLib.asmdef: add"GameCult.Geometry.dll"toprecompiledReferences.unity/org.gamecult.cultlib/Runtime/Plugins/GameCult.Geometry.dll.metaand.pdb.meta: new files. CopyGameCult.Caching.dll.meta's import settings and give them a fresh guid.unity/org.gamecult.cultlib/package.json:1.1.0.CHANGELOG.md,[1.1.0]→ Added: GameCult.Geometry (isosurface, surface nets, quad normals, geometry documents). It requiresorg.gamecult.cultmath0.3.0.- Also note in the changelog that this release carries the 25 commits touching
unity/org.gamecult.cultlib,src/GameCult.{Mesh,Caching,Networking}sincecultlib-unity-v1.0.60(git log cultlib-unity-v1.0.60..origin/main -- …). Aetheria inherits them in Cut 7b.
- Verification:
- Starfire, one job:
scripts/build-unity-package.ps1 -UpdateTemplate, run detached, exit 0. Then a second non-incremental run leavesgit statusclean; this is the byte-reproducibility rule. - The version check must fail when fed a cultmath
package.jsonat another version. Hands demonstrates this once, on a scratch copy, and reports it. - Unity: the Asura host project (Cut 4a) is not there yet. So a throwaway
scratch Unity project pins
cultlib-unity-v1.1.0(pushed to a scratch branch first, or afile:path) andcultmath-unity-v0.3.0, and callsCultGeometrySurfaceNets.Extractfrom an EditMode test. Zero compile errors. - Tags go at most three per push.
- Starfire, one job:
- Hands budget: ~150k tokens.
Cut 4a. Asura: Unity package skeleton, host project, headless Core
- Repo/branch: Asura
main54a748a. Hands commits code; Self commits the map. - Adds:
unity/org.gamecult.asura/ package.json name org.gamecult.asura, unity "6000.3"; no "dependencies": UPM package.json cannot declare git deps, so README states the required cultlib/cultmath tags README.md, CHANGELOG.md, LICENSE.md (match CultMath's MPL-2.0 unless the operator says otherwise) Runtime/Core/GameCult.Asura.Core.asmdef noEngineReferences: true; precompiledReferences GameCult.Geometry.dll, CultMath.dll Runtime/Core/*.cs AsuraBodyDefinition (Seed, Biome; no radius, D3/Q5), AsuraBiome (enum: Dunes, Craters|Rugged per Q4, plus analytic kinds Sphere, Box, CraterRim, Plane used as fixtures and as a legit baseline) Runtime/GameCult.Asura.asmdef references Core, CultMath.UnityBridge; engine refs Runtime/Shaders/ (empty until 4b) Tests/Editor/GameCult.Asura.Tests.Editor.asmdef testables via host unity/AsuraHost/ Unity 6000.3.24f1, Built-in RP, Windows APIs D3D11 then D3D12 Packages/manifest.json "org.gamecult.asura": "file:../../org.gamecult.asura", cultlib-unity-v1.1.0, cultmath-unity-v0.3.0, com.unity.test-framework; "testables": ["org.gamecult.asura"] ProjectSettings/* minimal; Library/, Temp/, Logs/, UserSettings/ git-ignored tests/Asura.Core.Tests/ Asura.Core.Tests.csproj net10.0; <Compile Include="../../unity/org.gamecult.asura/Runtime/Core/**/*.cs"/>; ProjectReference to CultLib GameCult.Geometry via a CultLibRoot sibling property (Aetheria.Shared's pattern, Aetheria.Shared.csproj:27-29), pinned to the cultlib-unity-v1.1.0 commit stryker-config.json mutate **/unity/org.gamecult.asura/Runtime/Core/**/*.cs .gitignore Unity host dirs, bin/obj, StrykerOutput - Contract rules, headless (Core tests, Stryker):
AsuraBodyDefinitionequality and hash cover Seed and Biome. Two definitions that differ only in Seed are unequal.- The seed-to-noise-offset derivation (
AsuraSeed.Offset(seed)) runs on the C# side and is uploaded, so the HLSL never re-derives it. It is deterministic, bounded (every component in[0, 256)so snoise keeps float precision), and distinct seeds give distinct offsets across a 10k-seed sweep. Use CultMath'spcg3d, not a local hash.
- Verification:
- Yggdrasil:
dotnet test tests/Asura.Core.Testswith a non-zero count, then Stryker. - Starfire: host batchmode EditMode run with one smoke test (the package compiles and Core types load). Log and PID in the scratchpad.
- Yggdrasil:
- Hands budget: ~150k tokens.
Cut 4b. Asura: HLSL planet field, grid sampling, batched async readback
- Adds:
-
Runtime/Shaders/AsuraField.hlsl, the one implementation of the planet field (invariant 2):- It includes
Packages/org.gamecult.cultmath/Shaders/CultMath.hlsl. - It exposes
float asura_field(float3 p, AsuraBodyGpu body), wherepis in body-local unit space (D3). Inside is<= 0, matching surface nets. f = |p| − 1 − displacement(p), withdisplacementswitching on the biome.- Dunes: large-scale banded ridges built from
cultmath_fbmand ridged terms, with amplitude big enough to move the silhouette. - Craters: bowls and rims from
cultmath_cellular, joined withmaxorcultmath_sminterms. - The analytic kinds.
Each biome declares
maxAbsDisplacement. - It includes
-
AsuraField.hlslalso exposesasura_field_gradient(p, body, h)as central differences. It serves Cut 6. CultMath has no analytic derivatives; if the benchmark shows the six extra evaluations are the cap, analytic snoise derivatives are a CultMath gap to fill there. -
Runtime/Shaders/AsuraSample.compute: one kernel samples every pending body's grid into one flatRWStructuredBuffer<float>. A per-body table holds offset, dims, origin, cell size, and the seed offset and biome. The linear index within a body is(x*ny + y)*nz + z. -
Runtime/AsuraSampler.cs:- Once per frame it packs the pending bodies up to a sample budget, makes one
dispatch and one
AsyncGPUReadback.Request(buffer, size, offset, cb). - It keeps a ring of K sample buffers. A buffer is never re-dispatched while its readback is in flight; when all K are in flight, it skips the frame.
- In the callback it copies each body's slice into a fresh
float[,,]with one memcpy (fixed (float* d = &grid[0,0,0])andUnsafeUtility.MemCpy).
- Once per frame it packs the pending bodies up to a sample budget, makes one
dispatch and one
-
Grid bounds per body are the cube
±(1 + maxAbsDisplacement + margin), with margin ≥ 1 cell. Origin and cell size are derived so that the edge samples are strictly outside.
-
- Mechanism probed in this pass: a C#
float[,,]'s memory is row-major.Buffer.BlockCopyof a flat(x*ny+y)*nz+zarray intofloat[2,3,4]lands[1,2,3] == 23. A net10 scratch probe confirmed it, so the GPU layout above memcpys straight into the arrayExtracttakes. - Authority map:
- Owner:
AsuraField.hlslowns shape. - Inputs: definition, level and seed offset.
- Outputs: grid samples.
- Derived: the
float[,,]copy is a cache, dropped once meshed. - Forbidden writers: any C# evaluation of the planet field; anything writing
the sample buffer except
AsuraSample.compute.
- Owner:
- Verification (Starfire, host EditMode tests on the real GPU, one job):
- Assert
SystemInfo.supportsAsyncGPUReadbackon the device. If it is false, Asura refuses loudly and keeps stand-ins. - Layout: the
Planekind (f = a·p + bwith distinct a.x, a.y, a.z), sampled on a 5×7×9 grid and read back intofloat[,,], equals the closed form at every index within float epsilon. This kills axis swaps and wrong strides. - Ring integrity: submit 4K bodies of the Plane kind with distinct
coefficients over consecutive frames (PlayMode,
yield return null). Every body's grid matches its own closed form, so no slice is overwritten in flight. - Closure bound: for each biome × 64 seeds × 3 levels, every boundary
sample is
> 0. This pinsmaxAbsDisplacement. - Determinism: the same definition sampled twice on this machine gives bit-equal grids. Invariant 6, same-machine; see Q7.
- Seed: two seeds of the same biome give different grids.
- negative:
rg -n "snoise|asura_field" unity/org.gamecult.asura -g "*.cs"→ 0. C# never evaluates the field.
- Assert
- Hands budget: ~200k tokens.
Cut 5a. Asura: worker-thread meshing and bare-mesh rendering
- Adds:
-
Core/AsuraBuildJob: a pure function taking(float[,,], origin, cellSize)toCultGeometrySurfaceNets.Extract, thenCultGeometryQuadNormals.FaceWeighted, then an immutable result. There is one body perTask. Inputs are owned copies; there is no shared mutable state (invariant 7). -
Runtime/AsuraSystem(MonoBehaviour), which owns the build lifecycle. Its port:Add(key, definition, Transform parent, Renderer standIn);Remove(key);SetCamera(Camera).
Build generations are keyed by
(key, level, generation). A result whose generation is stale, or whose body was removed, is discarded on the main thread. -
Mesh upload happens on the main thread:
Mesh.SetVertices(NativeArray)andSetIndices(..., MeshTopology.Quads)with face-weighted normals, under a per-frame upload budget. It renders with Unity's built-inStandardshader. No new shader in this cut. -
Core/AsuraLevels: projected pixel diameter to grid level, from a quantised table (for example 8, 12, 16, 24, 32, 48, 64). Downgrades have hysteresis. A level change remeshes, and the old mesh stays visible until the new one is ready. -
Stand-in switch. Asura owns it, through the
standInrenderer Aetheria passes in. For each body exactly one of the stand-in and the Asura mesh is visible at any frame after the first ready frame, and the stand-in is visible before that.
-
- Contract rules:
- In Core: level selection is monotone non-decreasing in pixel diameter and clamped. Hysteresis means a diameter oscillating ±1% around a threshold never changes level.
- In Core: builds of distinct bodies run in parallel and give results bit-equal to sequential builds.
- In Unity: stale results are discarded.
- In Unity: the stand-in exclusivity rule above.
- Verification:
- Core tests and Stryker on Yggdrasil.
- Host PlayMode on Starfire:
- a Dunes body at 3 levels meshes and closes (every edge used by an even number of quads, and exactly 2 at the tested seeds) on the real sampled grid, not a CPU fixture;
- removal mid-build leaves no mesh and no leaked
Mesh(countMeshobjects before and after); - the stand-in/mesh exclusivity rule is checked every frame across a level change.
- Hands budget: ~200k tokens.
Cut 5b. Asura: throughput benchmark with a committed baseline
- Adds:
- A host PlayMode test with
[Category("Benchmark")], excluded from default runs. It frames through PlayMode, so async callbacks fire as in play. - For each grid size in {8, 12, 16, 32, 64} (at least 3 are required), it submits a burst of M distinct seeds and measures steady-state bodies per millisecond from first submit to last mesh upload, excluding warm-up.
- It reports stage times: sample dispatch, readback latency in frames and ms, mesh ms per body on workers, and upload.
- Mode "mesh-only (tiles pending)" is measured here; Cut 6b adds the tiled columns.
- Output:
docs/benchmarks/<date>-<host>.md, a table. Its header records GPU name and driver, CPU, Unity version, Asura, CultLib and CultMath SHAs, and "editor PlayMode, batchmode". Committed.
- A host PlayMode test with
- Verification: the run on Starfire, one job, with no other heavy job running; the committed file. A player-build baseline is a recorded follow-up.
- Hands budget: ~120k tokens.
Cut 6a. Asura: the tile compute pass at uniform N
- Adds:
-
Core/AsuraPatchLayout: from quad count, mesh edges and N, it gives the offsets of the three regions of D4:Vvertex points;E × (N−1)edge points;Q × (N−1)²interior points.
It also derives mesh edges from the quad mesh, keyed
(min vi, max vi). Edge points are parameterised from the lower vertex index to the higher, so the parameterisation belongs to the edge and not to either quad. -
Runtime/Shaders/AsuraTiles.compute, with kernels for vertex, edge and interior points. Each point:- starts from its canonical position (the base vertex; lerp of the two refined endpoints; bilinear of the four refined corners);
- is refined onto
f = 0by normal-constrained Newton: a fixed iteration count, moving along the gradient direction at the start point, with the step clamped to one base cell; - stores the gradient normal and a biome material (packed RGBA8).
Vertex points are refined first, so edge and interior start points read refined corners.
-
A per-body
GraphicsBufferofAsuraPatchPoint {float3 position; float3 normal; uint material}(D5). -
Core/AsuraLevelsgains N selection from projected base-cell pixels (for example N in {1, 2, 4, 8, 16}), with the same monotone, clamp and hysteresis rules. -
Core's remesh/retile decision: an N change retiles only, and a level change remeshes and then retiles.
-
- Authority map:
- Owner: the tile kernels own tile contents.
- Inputs: field, quad mesh, N.
- Outputs: the patch buffer.
- Derived: everything in it is a cache (invariant 1).
- Forbidden writers: anything else writing the patch buffer; anything reading positions back as shape authority. The dock-site query in 7c evaluates the field, not the atlas.
- Verification (Starfire, host tests reading the buffer back):
- Refinement: on the Sphere kind at N ∈ {1, 2, 4, 8}, every point satisfies
| |p| − 1 | ≤ ε. At N = 1 this also shows base vertices snapped onto the surface. - Normals: on the Sphere,
dot(normal, normalize(p)) ≥ 1 − 1e-3at every point. - Dunes:
|f(p)| ≤ ε·cellfor every point, and no point moves more than one base cell. - Core tests and Stryker for the layout offsets and edge derivation (each unique edge appears once; key order is canonical).
- Refinement: on the Sphere kind at N ∈ {1, 2, 4, 8}, every point satisfies
- Hands budget: ~200k tokens.
Cut 6b. Asura: patch rendering and watertightness at uniform N
- Adds:
Runtime/Shaders/AsuraPatch.hlsl. It holds the one functionasura_patch_vertex(vertexId) → (point index, patch uv), which expands each quad into an N×N patch of2·N²triangles, reading corners, edges and interior from the D4 regions.AsuraPatch.shader(Built-in RP): the vertex shader calls that function and reads the patch buffer;ForwardBaselighting uses the stored normal and material. It draws withGraphics.RenderPrimitives(procedural, no mesh), one draw per body. Shadows are out of this cut.AsuraPatchExpand.compute: a verification kernel that calls the sameasura_patch_vertexand writes the expanded triangle positions into a buffer. It exists so watertightness is measured on exactly what the vertex shader emits, with no C# replica of the expansion.- Presentation: a body whose tiles are ready draws patches. Before that, the bare mesh (5a) is drawn with face-weighted normals as the stand-in. One of the two is visible at a time, per body.
- The benchmark (5b) gains columns: tiled at N ∈ {1, 2, 4, 8}, per grid size. A new committed results file is written; the old one is kept.
- Verification (Starfire):
- Watertight: for Sphere, Dunes and Craters at N ∈ {1, 2, 4, 8} × 2 levels,
read back
AsuraPatchExpand. Each undirected triangle edge, keyed by the exact bit patterns of its two endpoints, appears an even number of times, and exactly twice on the Sphere. Report per case the edge count and the number of odd edges (must be 0). - No folds: each triangle's normal has a positive dot product with the field gradient at its centroid.
- Exclusivity: the bare-mesh/patch switch never shows both and never neither, across a retile.
- operator: the dunes planet in the host scene, orbiting camera: the silhouette shows the dunes.
- Watertight: for Sphere, Dunes and Craters at N ∈ {1, 2, 4, 8} × 2 levels,
read back
- Hands budget: ~180k tokens.
Cut 6c. Asura: crease snapping from field gradients in the tile pass
-
Adds, in the tile kernels, after refinement, for every point (vertex points included, so N = 1 gets sharp base vertices and the mesher stays pure surface nets):
- It samples
asura_field_gradienton a stencil of fixed offsets in body-local space. The offsets depend only on (body, grid level): never on the quad, N or patch coordinates. - It clusters the gradients into families by an angle threshold.
- With 2 or more families, it solves a small QEF over the tangent planes (two planes give the nearest point on the crease line, three give the corner), regularised toward the refined point.
- It clamps the move to a fraction α of the patch cell (base cell ÷ N) so no triangle folds.
- It sets a "snapped" bit in the point's material word. This is the observation at the layer where the rule is decided, and it stays in production.
Prior art is cited in a comment block and in
docs/: Kobbelt et al. 2001 (Extended Marching Cubes, feature-sensitive sampling) and Ju et al. 2002 (dual contouring QEF). The implementation is fresh. - It samples
-
Do not add: a dual-contouring placement option in CultLib (ruling,
target.md, "Deferred paths"). -
Verification (Starfire, readback):
- Box kind at N ∈ {2, 4, 8}: every point within one base cell of a box edge lies within ε of the true edge line; points near corners lie on the corner; zero folded triangles (6b's fold check); watertight (6b's bit-edge check).
- Box at N = 1: base vertices near box corners land within ε of the corners.
- Sphere control: the snapped-bit count is 0, and the patch buffer is bit-equal to the output with snapping compiled out. The rule is "never triggers", not merely "small effect".
- CraterRim kind (a max of terms): points within one cell of the analytic rim circle lie within ε of it; zero folds; watertight.
- The benchmark gets one more run to record snapping's cost.
-
Hands budget: ~180k tokens.
Cut R. Asura release tag
asura-unity-v0.1.0on the commit that closes 6c. Package version0.1.0and CHANGELOG. The README states the required cultlib and cultmath tags. Soul passes before the tag is pushed.
Cut 7a. Aetheria: planet definitions from zone generation (headless)
- Repo/branch: Aetheria,
hands/asura-7a, based per Q1. Worktree. - Per-file changes (master
9b85211f):Assets/Scripts/ServerShared/ZoneData.cs:69-73:PlanetDatagains[Key(9)] uint Seedand[Key(10)] string Biome, using the Asura biome name. It is a string so ServerShared never references Asura; see the negative check below. The document version follows Aetheria's schema-evolution rule foraetheria.planetdata, and Hands reads that rule before choosing. Old records per Q3.Assets/Scripts/ServerShared/ZoneGenerator.cs:125-128(the Planet/Planetoid branch):- Seed comes from a local generator built from the zone's stable hash
and the planet's index in
planets. The zone generator already hashesgalaxyZone.Name.StableHash() ^ pcg3d(position).xat:48. - It never draws from the shared
randomstream. Drawing from it would shift every later draw at:143-196and:209+(belts, gas colours, stations), so existing galaxies would regenerate differently. - This is the same pattern as fire-control 6b's
CombatSeedplus a local generator (Zone.csonab14552a). - Biome comes from the seed per Q3.
- Seed comes from a local generator built from the zone's stable hash
and the planet's index in
- Contract rules (
tests/Aetheria.Shared.Tests, Stryker via the fire-control line'sstryker-config.json):- The same galaxy zone gives the same seeds and biomes.
- Distinct planets in one zone get distinct seeds.
- Every other field of the generated
ZonePackand its bodies is unchanged against a capture taken at the base commit. Capture it at the base, not from the new code.
- Negative:
rg -n "Asura" Assets/Scripts/ServerShared→ 0.Aetheria.Sharedcompiles ServerShared headless without the Asura package, so any reference fails that build. This is invariant 7 made structural: zone gen cannot build geometry. - Hands budget: ~120k tokens.
Cut 7b. Aetheria: Asura renders rocky bodies
- Per-file changes (master anchors; fire-control anchors differ by the
:292-301EngineAssets edits only):Packages/manifest.json:54-55:org.gamecult.cultlibtocultlib-unity-v1.1.0andorg.gamecult.cultmathtocultmath-unity-v0.3.0(Cut 3's coupling rule), and add"org.gamecult.asura": "https://github.com/GameCult/Asura.git?path=/unity/org.gamecult.asura#asura-unity-v0.1.0". Unity regeneratespackages-lock.json; commit it.ZoneRenderer.cs:- a serialized
AsuraSystem Asurafield next to:40, and anAsuraSystemobject inARPG.unitywired to it; SetCamera(MainCamera)inStart(:174).
- a serialized
ZoneRenderer.cs:394-403, the rocky branch: afterInstantiate(Planet), callAsura.Add(key, def(PlanetData.Seed, Biome), planet.Body.transform, planet.Body).planet.Bodyis theTerrain Meshrenderer:high-res-sphere.fbxwithPlanet.mat. It is the stand-in; see the finding on the target's "flat quad".- The Asura child transform's local scale equals the stand-in mesh's
bounds.extents.x, so the swap keeps apparent size (D3).
ZoneRenderer.cs:271-276(ClearZone):Asura.Remove(key)for each rocky key beforeDestroyImmediate.:497rotatesBody. The Asura child inherits the rotation, so nothing changes here.
- Verification (Starfire, Unity closed, one job):
- batchmode compile;
- the Aetheria EditMode suite;
- a PlayMode smoke: load a zone and assert that every rocky body reaches ready within T seconds, and that exclusivity holds;
- on the fire-control line,
EngineAssetCheck.Runexits 0; - operator: enter zones and see rocky planets as dunes or craters, varying by seed and stable across reloads. Gas giants and suns are unchanged.
- Hands budget: ~180k tokens.
Cut 7c. Docked view: dock-site query and raised N with per-edge stitching
- Blocked on Q6.
- Adds (Asura):
AsuraQuery.compute, which includesAsuraField.hlsl. For a body and a direction it finds the outermostf = 0crossing, marching inward from the bound and then bisecting, and returns the point and the gradient normal. Readback is async. This is the target's field query; it never reads the atlas.SetFocus(key, direction, radius): quads whose centres lie within the focus radius getN_hi, and the rest get the body's N.- Per-edge factor, keyed by the mesh edge (D4):
E(edge) = max(N_a, N_b). - The edge region holds
E − 1points per edge.asura_patch_vertexstitches each quad's boundary rows to its edges' factors. - The layout moves from uniform slots to per-quad offsets, computed in Core.
- Adds (Aetheria), per Q6:
- The dock-site direction is derived from the station's identity; Aetheria owns it.
ActionGameManager.cs:863-881(DoDock): when the parent orbit body is a rockyPlanetData, frame the close-up. The station asset is placed at the query point and aligned to the normal, andSetFocusis called. Otherwise the current dock camera path applies unchanged.Undock(:883+) clears the focus.
- Verification:
- Starfire:
- on the Sphere kind, the query returns
R·dir ± ε, with normal = dir; - watertight: 6b's bit-edge check at mixed N (focus on,
N_hi∈ {4, 8, 16} beside N ∈ {1, 2}), zero odd edges and zero folds; - Core Stryker on the per-edge factor and offsets.
- on the Sphere kind, the query returns
- operator: dock at a station orbiting a rocky planet. The station sits on the surface without floating or sinking, and there is no crack at the N boundary.
- Starfire:
- Hands budget: ~200k tokens. If Q6 adds the flattened pad (a
cultmath_sminof a plane into the field), split it into 7d.
Subtraction ledger (estimates)
| Cut | Removed | Added | Deps/targets |
|---|---|---|---|
| 1 | 310 files, 11,344 text lines, 16 LFS binaries, ~60 C#/YAML lines (+3 files per Q2) | 0 | −1 third-party plugin |
| 2a | 0 | ~90 C#, ~70 HLSL, ~150 test | cultmath-unity 0.3.0 |
| 2 | 0 | ~220 C#, ~300 test, 1 md, 1 Stryker config | none |
| 3 | 0 | ~20 script, 1 asmdef line, 2 metas, 1 DLL+pdb | cultlib-unity 1.1.0 |
| 4a | 0 | package skeleton, host project, ~150 C#, 1 test csproj | +1 Unity package, +1 host project, +1 test project |
| 4b | 0 | ~150 HLSL, ~200 C#, ~250 test | none |
| 5a/5b | 0 | ~350 C#, ~250 test, 1 results doc | none |
| 6a/6b/6c | 0 | ~450 HLSL, ~250 C#, ~400 test, 2 results docs | none |
| 7a/7b/7c | ~5 lines | ~150 Aetheria C#, ~250 Asura, ~200 test | Aetheria +1 UPM dep (asura) |
This is net additive, and deliberately so: the campaign buys a capability that did not exist (Asura). Cut 1 pays about 11k lines of unused third-party plugin toward it.
Operator questions
-
Q1. Which Aetheria line do Cuts 1 and 7 land on?
- A: wait until the fire-control line (
ab14552a, 218 commits ahead of master) merges to master, then branch from master. - B: branch from master
9b85211fnow. - C: stack on the fire-control line.
Recommended: A. Cuts 2–6 need nothing from Aetheria, so waiting costs nothing on the critical path. B would conflict with settings Cut 0's
GameSettings.csedits and with the manifest pins. C couples Asura to unreviewed in-flight work. - A: wait until the fire-control line (
-
Q2.
PlanetOutpost.prefabandLocations/ReconStationAlpha.{prefab,asset}use the plugin. Nothing but the content catalog (not yet decoded) could reference them.- A: delete them in Cut 1, if the decode finds no consumer.
- B: keep them, stripping the plugin component and material. Their bodies then render with no material.
Recommended: A. It is the subtraction cut, and PlanetOutpost's concept (a station on a planet) is what 7c builds properly. If the decode finds a consumer, Hands stops.
-
Q3. Seeds, biomes and old saves.
- (a) Seed from a local generator (zone hash and planet index) that never consumes the zone stream. Recommended, as above.
- (b) Biome: uniform by seed over Asura's biome set now, or banded by mass
(planetoid vs planet), using the existing
BodyType.Planetoid/Planetsplit atZoneGenerator.cs:117? Recommended: uniform now, with a mass band added later as aZoneGenerationSettingsentry. - (c) Stored
PlanetDatawithout a Seed, in existing runs: should they (A) fail loudly and be regenerated, or (B) derive a seed from the record key on load? Recommended: A. B is a compatibility path that keeps deciding shape forever. Is there any saved run you need to keep?
-
Q4. The second minimal biome.
- A: craters. This needs
cultmath_cellularin 2a, and craters are the asteroid look. - B: rugged fBm. It needs no extra CultMath.
Recommended: A. Asteroids are in scope, and the crater rim is the crease case 6c must prove anyway.
- A: craters. This needs
-
Q5. Do biome features scale with the body? Should a small rock and a large planet of the same biome look like scaled copies (unit-radius field, D3), or keep a world-space feature size (the definition carries a radius)? Recommended: scale with the body. It is the tiny-planet style, and it keeps float precision uniform. The target's "(seed, radius, biome parameters)" then loses radius from the Asura definition, and the world radius stays Aetheria's
BodyRadius. -
Q6. What is the docked view? Stations are generated orbital entities at Lagrange points (
ZoneGenerator.cs:208-215).DoDocktoday follows the station and looks at its parent planet (ActionGameManager.cs:863-881).- A: presentation only. When the station's parent is a rocky planet, the docked camera shows the station asset standing on that planet at a dock direction derived from the station's key. Simulation positions are unchanged. Stations around gas giants or suns, or with no parent, keep today's view.
- B: authored dock sites per station.
Recommended: A. Also: should the flattened pad under the station ship in 7c, or wait for clipping to show it is needed? Recommended: wait.
-
Q7. Invariant 6, "on any machine". CultMath's HLSL parity is proved on the CPU: the text of the mirror is compiled as C#. Its own test comment says it "does not prove GPU agreement". Because the field is GPU-only, grids can differ in low bits across GPUs and drivers, and a sample near 0 can flip a quad.
- A: reword to "bitwise on one machine; across machines within tolerance. Nothing persisted or networked depends on shape bits."
- B: require cross-machine bit equality. That would need a CPU field, which contradicts F1 path A.
Recommended: A.
-
Q8. Belt asteroids. Belts are thousands of instanced meshes from
LowPoly_AsteroidsPack(ZoneRenderer.cs:339-363).- A: this campaign covers
PlanetDatabodies (planets and planetoids) only. Belts get a later cut sized by the 5b/6b benchmark, for example a pool of K Asura rocks per belt, instanced. - B: include belts in Cut 7.
Recommended: A. The Jevons ruling makes the benchmark the right gate.
- A: this campaign covers
-
Q9. Licence of the Asura package. CultMath is MPL-2.0 and Aetheria source is MPL-2.0; the cultlib package is MIT. Recommended: MPL-2.0, matching Aetheria and CultMath.
Findings for Self (target reconciliation; not assigned to a cut)
-
The target's "flat body/icon/gravity-well quads" is half wrong.
Bodyis theTerrain Meshobject:Assets/Models/high-res-sphere.fbxwithAssets/Materials/Planet.mat(GlowFade shader). OnlyMinimap Icon(layer 14) andGravity Wellare quads (Planet.prefab:15,43,98,126,254,282). The main-view stand-in is that sphere, not "the flat icon". -
The target's "no scene instantiates it" is half wrong.
Planet.prefabcarries a disabled generator.PlanetOutpost.prefabcarries an enabled one.ARPG.unityruns an enabledLODHandler.ZoneRenderer.cs:400assigns random plugin settings per planet withUnityEngine.Random.
The plugin's meshes never generate in play, because the planet generator is disabled, but it is wired in.
-
The target's substrate pins (cultlib 1.0.60, cultmath 0.2.4) are the fire-control line's. Master pins 1.0.59 and 0.2.3 (
Packages/manifest.json:54-55). -
An unmerged prior planetary line exists in CultLib: tag
gamecult-geometry-unity-v0.1.0andorigin/codex/geometry-*, dated 2026-07-22, with a cube-sphere heightfield, erosion, GPU pages and anorg.gamecult.geometryUnity package. Its progress doc stops at "Stage 6 consumer cutover … Gate pending". Main'sGameCult.Geometrywent another way (isosurface, 2026-08-26). Add it to the target's "Not consumers", so no pass mistakes it for Asura's substrate. Its fate belongs to whoever owns the geometry-ownership migration, not to this campaign. -
The target mentions smooth-min bevels and pads, but CultMath has no smin. Cut 2a fills that gap.
-
Identity table: propose a row for "mesh edge (vertex-index pair ≙ grid face) → edge point block, per-edge factor" (D4 and 7c). Its lifecycle matches the tile slot's, its owner is the Asura tile pass, and it is regenerable.
-
Aetheria's
settings-globals-cut.mdfork B (:527-535) plans to move the plugin's 7 body-settings assets intoResources. F2 supersedes that; sweep it. -
ZoneRenderer.cs:497rotatesBodybyPlanetRotationSpeedper frame, not per second, so planet spin depends on frame rate. It is not Asura's concern; record it as an Aetheria follow-up. -
Missing substrate: the voidbot MCP was unreachable (connection timeout) for this pass, so everything here comes from direct git reads and probes.