5 Commits

Include renames

Author	SHA1	Message	Date
adminandClaude Opus 5.5	32a0af6e2c	Put the text and boxes of the interface on device pixels ... On a screen scaled to 125 % or 150 % the editor looked soft beside a page the browser draws itself. The layout counts in whole CSS pixels, and most of those fall between two device pixels there. The GPU averages both: text loses its edges, and a 1 px line becomes a pixel and a half of mixed colour. Now text and boxes are rounded to device pixels, and a line is one device pixel wide. - ui/pixelGrid.ts holds the rule. crispText() makes a text with Pixi's roundPixels, crisp() does the same for a Graphics of upright boxes, and hairline() is the width of one device pixel. - Every text of the interface is made with crispText() instead of new Text(). - crisp() only rounds where the scale is not a whole number. At 100 % and 200 % nothing changes. - drawControlBox, drawHeaderBar and drawSectionBand draw their lines a hairline wide and flush with the edge. The widgets that draw lines of their own do the same. - Two bands share exactly the line they draw, and a column still ends on a whole pixel. - The stage is nudged by 1/32 px where the scale is not whole. At 150 % every odd pixel is an exact half, and without the nudge one band came out a row shorter than its neighbours. - Curves, icons and everything of the game stay unrounded. Rounding their points would bend them. - The harness takes deviceScaleFactor as an option, and the hooks deviceColumn, edgeContrast and pixelGrid read the frame as the screen gets it. Not in here: the subpixel smoothing a browser gives its own text. Pixi draws a text into a transparent picture first, and there only greyscale smoothing is possible. Measured at 150 %, edge contrast before and after: top bar 31.5 to 47.8, the lists on the left 68.6 to 86.4, inspector 27.6 to 38.4. At 100 % it is 46.5, 90.1 and 37.9, and the picture there is the same as before pixel for pixel, apart from the fps display. Tests: - Gate on melektaus-atx: 206 files, 3114 tests (3104 + 10), exit 0 - Full run on melektaus-atx: 1655 of 1656 checks passed, smokes 24/19/21. The one that failed was a condition of the new step 62 itself: it scrolled an inspector that had nothing to scroll. The step now makes the window lower for that reading. - e2e 61,62 after that fix: 14 checks. The full run was not repeated, and CI is switched off for now. - Ten unit tests, nine in tests/ui/pixel-grid.test.ts - Eight e2e checks in the new step 62, which runs at 150 % - Eleven unit counter-probes fail tests - Four browser counter-probes fail their checks. They ran before the fix to step 62 and were not repeated for it. - Screenshots looked at for 125 % and 150 % Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-02 08:42:26 +02:00
rootandClaude Opus 5	d5e67cd80c	A shader costs a source nothing, because a field was already one draw call (#88) ... A particle source can wear a shader asset the way a sprite does, and it is the cheapest place in the editor to wear one: a shaded sprite gives up its batch and costs a draw call of its own, while `ParticleContainerPipe` breaks the batch for every field regardless. Five hundred shaded particles are the one call five hundred plain ones were. The fragment the compiler emits needed no change, only a second vertex stage: Pixi's particle vertex is GLSL ES 1.00 and ours is ES 3.00, so it is translated rather than invented. What it sees is a particle's picture, not its life — the buffer carries five fixed attributes and takes no sixth, so age, index and seed stay on the graph, which is what the graph is for. Two things the issue did not ask about: `Shader.resources` is an accessor over the names its constructor declared, so a slot that is not declared becomes a loose JS property and is never bound. The adaptor writes `uTranslationMatrix` into whichever shader the container names — without an empty block for it the vertex gets no matrix and the particles land elsewhere. `schemaOf` in serialize.ts hung on `schema !== schemaFor('sprite')`, an identity check a source never satisfies, so its shader values would have been dropped on save. A source is the one asset drawing rows from two graphs, so a name can arrive twice. Its own row wins and the uniform keeps its default; nothing is rejected on the shader's side, because the collision exists only at this one wearer. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-14 11:06:45 +02:00
rootandClaude Opus 5	0e0a21dee1	One clock under everything that moves by itself (#90) ... Particle age and shader time each read performance.now() off their own library, and the world got the frame's delta straight from the ticker. Three clocks, so a global time scale would have been three multiplications and a pause three separate freezes. core/time.ts holds one clock instead: it accumulates dt x scale per frame rather than reading the wall clock, and Editor.tick hands the very step it took to the play session, the editor run and the animation preview. Delta time, particle age, shader time and that preview are the same quantity now, so the scale is a single multiplication and a pause is that scale at 0 — nothing underneath needs rebasing, because the clock itself stands still. The Math.min(dt, 0.1) caps in PlaySession and EditorRun are gone: the cap (MAX_FRAME) now sits on the raw frame before scaling, and capping twice would make the world run slower than the particles at scale 2. A pause gates the scale rather than overwriting it — effectiveScale() answers 0 while paused, and for anything that is not a positive finite number, while gameClock.scale keeps its value. A slider later survives a pause that way; the issue asks for none yet. The clock goes back to zero at both ends of a run, so a run is reproducible from second 0 and the scene view looks freshly loaded after Stop. Resetting only on Stop would not do it: the editor clock runs on afterwards, and the next Play would start at "seconds since the last Stop". The trap in that: ParticleField keeps its origin as an absolute second of this clock, so after a reset it lies in the future and every particle would age backwards. One line in sync() starts such a field over, which covers the scene, the game and the tab preview at once — and fixes an older bug of the same shape, where releasing a particleTime() freeze left the preview empty for good. Found while measuring that: ParticlePreview stood at second 0.5 by computing the clock reading that would mean 0.5 since the field started. Over 200000 random origins the round trip misses the last bit in 18.8% of them and shows one particle too few in 9.4%, because floor(0.5 * 20) comes out 9. The check had been flaky since it was written. The panel hands the field the age itself now (ParticleField.hold), and the faked clock is gone. 833 checks (824 + 9), 931 unit tests (921 + 10). Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-14 09:31:53 +02:00
rootandClaude Opus 5	fbb2d157f0	A held preview is rebased, not paused, and it wears the asset's own rows (#86) ... Three reports plus one found on the way. Hold only froze the *picture*: the preview computed a fake second while drawing, the library clock kept counting underneath, so letting go jumped to "how much would have passed by now". That is the flip side of the formula model — a thing that is a function of the clock is not stopped, its origin is moved. ParticleField.rebase() does that; hold(null) calls it with the second stood at. The Hold label now mirrors the preview's state instead of its own click history, so dragging the slider (which holds too) reads `Run`, and Restart puts a held preview back to 0.00 s rather than leaving it on the second it stopped at. previewProps only read defaultsFor('particles'), so the panel showed the type's defaults while the inspector showed the asset's rows. AssetBase.props is a full bag on a graph asset as well — asset.props now lie over the defaults, the asset's texture is resolved instead of always drawing a white square, and the slider's span follows its lifetime. The span is re-read in tick(), because the rows are edited in the inspector and the tab hears nothing about it. The preview moves from under the graph to beside it, past a draggable splitter: a graph is read across, so width is what it can spare and height is not. AssetTabEditor grows a body() hook for that — the base class still stacks header, strip and canvas, a subclass may put something next to the canvas. Found by the full run, not reported: the graph canvas's empty-state hint ran 38 px past its frame now that the preview takes 280 px away. It is cut with truncate() like any other label. 816 checks (809 + 7). Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-14 07:03:51 +02:00
root	0f9e1611d1	A particle is a function of its age, not a thing that is stepped (#73) ... The asset type `particles` is placeable and carries a graph at the same time — `behavior` was the blueprint. Because a continuous emitter gives birth to particle n at time n/rate, the whole field is a function of the clock rather than of the frames: no ring-buffer bookkeeping, exact time jumps, reproducibility as a measurable property. compile.ts follows compileShader's frame but emits JS closures into a Float64Array instead of GLSL, and without eval; a node with two consumers is evaluated once. Drawing is one Pixi ParticleContainer per source, so one draw call. Collision, wind and braking in flight are out for good — that is the price of the formula model, not an omission. The tab count goes from nine to ten, which is exactly the case #84 was built for one day earlier: at 1280 px the row no longer holds every tab, so guard 14b now asks for hidden.length > 0 instead of === 0.	2026-09-14 05:44:25 +02:00