Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

chore: prepare v0.92.0 release

yhh1b7dc9ccc725
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6c1ed5637..bb1751978 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,29 @@ published separately; it ships inside the editor.
## [Unreleased]
+## [0.92.0] - 2026-10-18
+
+### Added
+
+- **Material graphs have a Tiling & Offset node.** Scale and offset UV coordinates with one node in the material graph editor.
+- **Material graph editor polish.** Subgraph connections use the type the subgraph returns, a multi-selection drags together, and depth-only mesh programs no longer warn about an unused texture.
+- **Material graphs have switches, a live preview and extract-to-subgraph.** Build shader variants with Switch nodes, preview graph changes live, and turn a selected group into a reusable subgraph.
+- **Material graphs can bend a mesh and its shadow.** The output exposes vertex offset with an authored bounds expansion; the deformed mesh casts its deformed shadow.
+- **Material graphs can output a standard PBR surface.** Normal, metallic, roughness, occlusion, emission and alpha inputs join the standard material output.
+- **Material graphs can use other graphs as nodes.** Reusable material subgraphs are compiled inline into the parent graph.
+- **The Plugins panel shows conflicts and what disabling removes.** Inspect ID conflicts, filter plugins by phase, and preview the contributions removed by disabling a plugin.
+- **The Agent panel is redrawn.** Run outcomes, steps and acceptance results have a clearer layout.
+- **The Project Health panel is redrawn.** Filter by severity, group findings, and see checks that could not run.
+- **The UI debugger is redrawn.** Text and focus order use tables; event propagation is shown as a chain.
+- **The UI Widgets palette is a searchable, grouped list.** Find widgets by name within their groups.
+- **The World panel is a table of cells beside the Content Browser.** Inspect streaming cells in the same workspace as project assets.
+- **The Spine preview, running-game inspection and the Game panel states are redrawn.** These views share the editor’s updated controls and status presentation.
+- **The lighting, history, scatter, plugins and string table panels are redrawn.** Lighting keeps bake controls pinned, history marks the current state, the scatter brush previews itself, plugins have a list and detail view, and string tables number their rows.
+- **The script, material and behavior-tree graph editors are redrawn.** Graph nodes share one design; script variables have a searchable panel beside the canvas.
+- **The sequencer and the sound event editor are redrawn.** Key shapes show interpolation, tracks show values, sound variants show waveforms and shares, and attenuation is drawn.
+- **The profiler and the frame debugger are redrawn.** A module rail, CPU timeline and cost table organize profiling; the frame debugger names passes, columns and break reasons.
+- **Editor polish and plugin compatibility.** The Scene Report example accepts supported editor versions from 0.33 onward. Controller bindings wrap long names, UI debugger spacing is retained, collision material fields are aligned, and warnings and lighting bake summaries take less space.
+
### Changed
- **Gizmos are redrawn.** The transform handles are larger and clearer: arrows have filled heads, rings dim on their far side, the scale handles are solid cubes, and the part under the cursor turns yellow while the others fall back as you drag. A chip beside the cursor reads the offset, angle or factor being applied (`X +120.0`, `Y 42.5°`, `X ×1.35`), a rotate drag fills the swept angle, a move leaves a ghost where it started and, with snapping on, ticks at each increment. The entity under the cursor is outlined faintly before you click it, and a selected entity's outline is a little heavier. A selected mesh shows corner brackets with the length of three edges and its triangle and vertex count in the readout, the Show menu can draw its wireframe and normals, and a skinned mesh or one of its bones shows the skeleton as bones with the chosen joint in yellow. A decal projector shows its box and the line it projects along, a light probe volume the grid of probes a bake would lay, a LOD group the level it is showing and the share of the screen it takes, and the Gizmo menu has a handle-size slider. A selected UI node shows its margin and padding as bands, the pinned insets of an absolutely placed node as dashed lines with their values, and a flex container's direction and the gaps between its children. The six faces of a light probe volume, reflection probe or decal projector are handles: drag one and that half of the box follows the cursor. A selected mesh is outlined along its own silhouette rather than a box, up to 80,000 triangles. The Show menu can draw wireframe on every mesh at once, and choosing a bone paints the surface it moves from blue to red, the rest left grey; convex colliders now draw with the other 3D colliders. A Hunter's attack range is drawn as a red ball, a Perceiver's sight as the cone it actually tests (a ball when its field of view is all round), and a ThirdPersonCamera's boom as a line from the point it looks at to where it ends up, with the probe swept along it as a ball at the end. A UI element drawn as 9-slice shows its picture under its Slice Border field with four guides to drag, as the texture inspector does; while the texture carries a border of its own, which the renderer prefers, it says so instead. A selected Spine or DragonBones entity shows its bones over the artwork as the 3D rigs do, laid where the runtime posed them this frame, with the entity's scale and flips applied; the Spine and DragonBones modules gained a call that lists the bone tree, so a module built before it still draws the skeleton and only the bones are absent. A selected tilemap layer reports its tile count and the size of the area its tiles cover in the viewport readout (`172 tiles · 32×17`), and on a square grid outlines that area, so an infinite layer's edge can be seen. The profiler is laid out as a module rail (Frame, CPU / GPU, Render, Counters, Memory, Systems, Spine) beside the module chosen: its timeline plots what the CPU was busy with and no longer the wait for the next frame, so a healthy window is no longer one flat block and a hitch is a tall column; clicking a column pins that frame and the strip beneath says in a sentence how far over budget it ran and where; the cost tree is a table of total, own cost and share of the frame, in columns; the toolbar is icon buttons with the live state as a pill. The frame debugger's draw list has column headers, a header per pass with its draw count, a swatch for each draw's type, a break-reason filter that starts with All, and the position of the selected draw in the capture. The sequencer's keyframes take the shape of how the curve leaves them (round smooth, diamond linear, square held, round with an arc eased) in the colour of their track, a group's row sums up the keys beneath it, each channel row shows its value at the playhead beside a swatch that is its curve's colour, the ruler marks seconds as well as frames, the playhead's flag carries the frame, the record button is red and the snap toggle says what it is; the curve view marks its grid and names the selected key's frame, value and interpolation. The sound event editor lists its variants as a table with each clip's waveform and the share of the draw its weight takes, groups its settings (playback, level and pitch, voices, space), draws volume and rate as ranges, plots the attenuation curve with the function the runtime uses, and leads its preview bar with the Trigger action. The Show menu also picks how the viewport shades meshes: as authored, as neutral clay (shape, without anyone's colours) or as flat albedo (base colour, no light); the engine takes it as per-view state, so a camera preview in the same frame keeps the authored look. A fourth shading, wireframe, draws every triangle edge on a dark surface with the hidden ones hidden; the engine's pipelines now carry a primitive topology, WebGL2 and WebGPU alike, and each mesh the editor loads keeps a line list of its distinct edges. Script graphs, material graphs and behavior trees share one node look: a header in the colour of what the node is for, an icon and a plain name with the stored id small beside it, round pins that are solid when wired and hollow when not (control pins are triangles), and wires coloured by the type they carry. A graph with no saved positions is laid out left to right when it opens and opens no smaller than half size, and an Arrange button lays any graph out again. A script graph's inputs, outputs and variables are a searchable list beside the canvas that shows how often each variable is read and written, lights the nodes that use the selected one, and lets you drag a variable onto the canvas to get or set it. The Lighting panel folds into groups with a short state beside each title, shows its warnings as a plain row with an amber edge rather than an amber box, and keeps the bake state, counts and the Bake button pinned at the bottom. The History panel draws a rule at the present, with undone steps below it. The scatter brush draws one real sample of itself to scale. The Plugins panel is a list grouped by origin, with search, beside the details of the plugin picked: its actions, declared capabilities, what it contributes and its health. The string table numbers its rows, marks a missing translation with an amber edge and totals its problems in a status bar. The Spine preview in the asset inspector uses the editor's own dropdowns and icon buttons, shows the time against the animation's length, and names the bounds drawn over it (fixed, unsaved, last scan). While a running game is inspected, the selected entity's outline carries its name, the move handles have arrowheads, and a chip beside the handle reads the position, turn or scale being applied. The Game panel says it is idle, starting or failed with an icon, and a failure shows its reason in a block that can be selected. The World panel is a short panel beside the Content Browser: a toolbar with the cell count and size, the persistent entities as a count that opens their list, and — while the game runs — what is in each residency state, the hit rate and the last demand-to-resident time; below it a table of cells with their entity count and, at runtime, state, prefetch result and demand-to-resident time, and the entities of the picked cell beside it. Picking a cell frames its entities in the viewport. The UI Widgets palette is a searchable list in groups (layout, display, input, popup, touch controls) with the Chinese name and the widget's own name on each row, instead of a grid of tiles. The UI debugger's four views are laid out alike: the Elements tree shows each element's main component and its picked element's size and components sit beside it; Text and Focus order are tables with a state dot per row and select on a click of the row; Events draws each dispatch's bubbling path as a chain from its target. Project Health's three counts filter the list, its findings are grouped by severity under folding headings, and the checks that could not run are listed with their reasons instead of in a tooltip. In the Agent panel each run's header carries a dot for how it came out (running, held, not held, stopped early, never checked), a run's steps hang on a rail with a dot each, the acceptance line is ruled off like the change set instead of boxed, and the key hints under the input show while you are typing. The Plugins panel lists the ids a plugin and another owner both claimed and who got them, filters the list to failed, awaiting-trust, incompatible or shadowed plugins, no longer offers a built-in plugin a trust withdrawal that cannot hold, and says what a plugin contributes before disabling it. A material graph can now use another graph as one node: a `.esmatsub` material subgraph has inputs (a name, a type and a default each) and one result, a graph that uses it fills the inputs by wire or by typing a number on the node, and the compiler inlines it, so one subgraph used twice makes two independent copies and saving a subgraph recompiles the shaders of the graphs that use it. New ones come from the Content Browser's New menu; the subgraph's own header says how many graphs use it. A material graph's output node takes the standard material's surface: normal, metallic, roughness, occlusion and emission ports (and an alpha port that also works on an unlit graph), with a typed number for any left unwired. Connecting any of them compiles the graph to the same lit mesh shading the built-in Model material uses — metal read from blue and roughness from green, occlusion on the ambient light only, emission added after lighting — and a graph with none of them compiles exactly as before. New nodes: Normal Map, which reads its texture as data and unpacks it the way the standard material does, and Channel, which takes one of R, G, B or A as a number; a texture node can be set to read its map as data. The output node also has a vertex offset port: a number moves each vertex along its normal, a vec2 or vec3 moves it by that displacement, so a graph can sway foliage or ripple water; the mesh's shadow bends the same way, and a Vertex bounds field on the node says how far the offset can reach so culling keeps a bent mesh that is still on screen. The offset runs on lit 3D meshes only, and its graph cannot sample textures or read the screen. A Switch node makes a variant: it takes two values and a switch name, and the material turns the switch on or off to choose which one its shader is compiled with, so the side not chosen costs nothing at run time. The graph editor draws the graph as it is now, on a ball, cube or quad in its corner, a moment after each edit and before saving, with a checkbox per switch to look at each variant. Select nodes with shift- or ctrl-click and Extract to subgraph moves them into a new `.esmatsub` beside the graph: every wire from outside becomes an input, the one node something outside reads becomes the result, and the graph keeps one node in their place; a node of a subgraph draws its wire in the type the subgraph returns, and a selection of several nodes moves together when one is dragged. A Tiling & Offset node scales a UV and shifts it, for a texture that repeats or slides.
@@ -14614,7 +14637,8 @@ not kept before this file was introduced — see the Git history at
`github.com/esengine/estella` for the full commit-level record since the first
commit on 2026-01-25.
-[Unreleased]: https://github.com/esengine/estella/compare/v0.91.0...HEAD
+[Unreleased]: https://github.com/esengine/estella/compare/v0.92.0...HEAD
+[0.92.0]: https://github.com/esengine/estella/compare/v0.91.0...v0.92.0
[0.91.0]: https://github.com/esengine/estella/compare/v0.90.0...v0.91.0
[0.90.0]: https://github.com/esengine/estella/compare/v0.89.2...v0.90.0
[0.89.2]: https://github.com/esengine/estella/compare/v0.89.1...v0.89.2
diff --git a/SECURITY.md b/SECURITY.md
index faff1c39b..1970798d2 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -7,8 +7,8 @@ upgrading to the latest release is the supported path to a fix.
| Version | Supported |
|---------|-----------|
-| 0.91.x | Yes |
-| < 0.91 | No |
+| 0.92.x | Yes |
+| < 0.92 | No |
`tools/check-release-metadata.mjs` fails the build if this table stops matching
the version being shipped, so it cannot quietly fall behind again.
diff --git a/desktop b/desktop
index bcf3a1c42..ce9e6c0ab 160000
--- a/desktop
+++ b/desktop
@@ -1 +1 @@
-Subproject commit bcf3a1c420af429254c92da63ce961de609f6f06
+Subproject commit ce9e6c0ab469007aa5c21909ad8c8e419c3ce2c6
diff --git a/docs/astro/src/data/apiStability.generated.json b/docs/astro/src/data/apiStability.generated.json
index 36bc1b85c..36927d000 100644
--- a/docs/astro/src/data/apiStability.generated.json
+++ b/docs/astro/src/data/apiStability.generated.json
@@ -2,11 +2,11 @@
"note": "Generated by tools/api-stability.mjs from sdk/etc/*.api.md — do not edit.",
"counts": {
"public": 115,
- "beta": 121,
- "experimental": 2221,
+ "beta": 130,
+ "experimental": 2228,
"deprecated": 3
},
- "total": 2457,
+ "total": 2473,
"subsystems": [
{
"id": "mobile-controls",
@@ -2778,6 +2778,30 @@
"minigame"
]
},
+ {
+ "name": "SubgraphInput",
+ "kind": "interface",
+ "deprecated": false,
+ "entries": [
+ "index",
+ "index.node",
+ "index.native",
+ "wechat",
+ "minigame"
+ ]
+ },
+ {
+ "name": "SubgraphResolver",
+ "kind": "type",
+ "deprecated": false,
+ "entries": [
+ "index",
+ "index.node",
+ "index.native",
+ "wechat",
+ "minigame"
+ ]
+ },
{
"name": "ThemeColors",
"kind": "interface",
@@ -3070,6 +3094,30 @@
"minigame"
]
},
+ {
+ "name": "extractSubgraph",
+ "kind": "function",
+ "deprecated": false,
+ "entries": [
+ "index",
+ "index.node",
+ "index.native",
+ "wechat",
+ "minigame"
+ ]
+ },
+ {
+ "name": "flattenSubgraphs",
+ "kind": "function",
+ "deprecated": false,
+ "entries": [
+ "index",
+ "index.node",
+ "index.native",
+ "wechat",
+ "minigame"
+ ]
+ },
{
"name": "installNativePlatform",
"kind": "function",
@@ -3110,6 +3158,18 @@
"minigame"
]
},
+ {
+ "name": "newMaterialSubgraph",
+ "kind": "function",
+ "deprecated": false,
+ "entries": [
+ "index",
+ "index.node",
+ "index.native",
+ "wechat",
+ "minigame"
+ ]
+ },
{
"name": "nodeAdapter",
"kind": "const",
@@ -3202,6 +3262,42 @@
"minigame"
]
},
+ {
+ "name": "subgraphInputs",
+ "kind": "function",
+ "deprecated": false,
+ "entries": [
+ "index",
+ "index.node",
+ "index.native",
+ "wechat",
+ "minigame"
+ ]
+ },
+ {
+ "name": "subgraphOutputType",
+ "kind": "function",
+ "deprecated": false,
+ "entries": [
+ "index",
+ "index.node",
+ "index.native",
+ "wechat",
+ "minigame"
+ ]
+ },
+ {
+ "name": "subgraphRefs",
+ "kind": "function",
+ "deprecated": false,
+ "entries": [
+ "index",
+ "index.node",
+ "index.native",
+ "wechat",
+ "minigame"
+ ]
+ },
{
"name": "themeColors",
"kind": "function",
@@ -3237,6 +3333,18 @@
"wechat",
"minigame"
]
+ },
+ {
+ "name": "validateSubgraph",
+ "kind": "function",
+ "deprecated": false,
+ "entries": [
+ "index",
+ "index.node",
+ "index.native",
+ "wechat",
+ "minigame"
+ ]
}
]
}
diff --git a/package.json b/package.json
index 29a8577c4..c56a817e9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "estella",
- "version": "0.91.0",
+ "version": "0.92.0",
"private": true,
"type": "module",
"description": "Estella - A fast 2D/3D game engine powered by WebAssembly and ECS",
diff --git a/sdk/src/ecs/bridge/nativeEngineApi.generated.ts b/sdk/src/ecs/bridge/nativeEngineApi.generated.ts
index 44d78d976..999aa0a61 100644
--- a/sdk/src/ecs/bridge/nativeEngineApi.generated.ts
+++ b/sdk/src/ecs/bridge/nativeEngineApi.generated.ts
@@ -198,15 +198,15 @@ export interface NativeEngineApi {
renderer_setDepthLayers?(mask: number): void;
renderer_setEntityDrawOrder?(registry: unknown, entitiesPtr: number, count: number): void;
renderer_setLodPreview?(view: number, entity: number, level: number): void;
+ renderer_setMeshEdgeBuffers?(enabled: boolean): void;
renderer_setQualityBudgets?(atlasSize: number, cellSize: number, cascades: number, particleLimit: number): void;
renderer_setShadowDistance?(distance: number): void;
- renderer_setMeshEdgeBuffers?(enabled: boolean): void;
- renderer_setViewShading?(view: number, mode: number): void;
- renderer_setViewSkinWeights?(view: number, entity: number, joint: number): void;
renderer_setStage?(stage: number): void;
renderer_setTextureParams?(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void;
renderer_setViewId?(view: number): void;
renderer_setViewLighting?(mode: number, rotationDegrees: number, keyIntensity: number, fillIntensity: number, skyIntensity: number, showSky: boolean): void;
+ renderer_setViewShading?(view: number, mode: number): void;
+ renderer_setViewSkinWeights?(view: number, entity: number, joint: number): void;
renderer_setViewport?(x: number, y: number, w: number, h: number): void;
renderer_setYSortLayers?(mask: number): void;
renderer_shadowStatus?(entity: number, outPtr: number): number;
@@ -501,15 +501,15 @@ export function createNativeEngineApi(
bind('renderer_setDepthLayers', 'es_renderer_setDepthLayers', false);
bind('renderer_setEntityDrawOrder', 'es_renderer_setEntityDrawOrder', true);
bind('renderer_setLodPreview', 'es_renderer_setLodPreview', false);
+ bind('renderer_setMeshEdgeBuffers', 'es_renderer_setMeshEdgeBuffers', false);
bind('renderer_setQualityBudgets', 'es_renderer_setQualityBudgets', false);
bind('renderer_setShadowDistance', 'es_renderer_setShadowDistance', false);
- bind('renderer_setMeshEdgeBuffers', 'es_renderer_setMeshEdgeBuffers', false);
- bind('renderer_setViewShading', 'es_renderer_setViewShading', false);
- bind('renderer_setViewSkinWeights', 'es_renderer_setViewSkinWeights', false);
bind('renderer_setStage', 'es_renderer_setStage', false);
bind('renderer_setTextureParams', 'es_renderer_setTextureParams', false);
bind('renderer_setViewId', 'es_renderer_setViewId', false);
bind('renderer_setViewLighting', 'es_renderer_setViewLighting', false);
+ bind('renderer_setViewShading', 'es_renderer_setViewShading', false);
+ bind('renderer_setViewSkinWeights', 'es_renderer_setViewSkinWeights', false);
bind('renderer_setViewport', 'es_renderer_setViewport', false);
bind('renderer_setYSortLayers', 'es_renderer_setYSortLayers', false);
bind('renderer_shadowStatus', 'es_renderer_shadowStatus', false);
diff --git a/src/esengine/renderer/rhi/GLDevice.cpp b/src/esengine/renderer/rhi/GLDevice.cpp
index bb69d5aeb..21bbd42f2 100644
--- a/src/esengine/renderer/rhi/GLDevice.cpp
+++ b/src/esengine/renderer/rhi/GLDevice.cpp
@@ -1041,27 +1041,27 @@ void GLDevice::backendInvalidatePipelineCache() {
// =============================================================================
/** The mode the bound pipeline's topology means. */
-u32 GLDevice::glPrimitiveMode() const {
+u32 GLDevice::primitiveMode() const {
return current_topology_ == GfxTopology::Lines ? GL_LINES : GL_TRIANGLES;
}
void GLDevice::drawElements(u32 indexCount, GfxDataType indexType, u32 byteOffset) {
if (!isDeviceUsable()) return;
prepareVertexState();
- glDrawElements(glPrimitiveMode(), static_cast<GLsizei>(indexCount), toGLDataType(indexType),
+ glDrawElements(primitiveMode(), static_cast<GLsizei>(indexCount), toGLDataType(indexType),
reinterpret_cast<const void*>(static_cast<uintptr_t>(byteOffset)));
}
void GLDevice::drawArrays(u32 first, u32 vertexCount) {
if (!isDeviceUsable()) return;
prepareVertexState();
- glDrawArrays(glPrimitiveMode(), static_cast<GLint>(first), static_cast<GLsizei>(vertexCount));
+ glDrawArrays(primitiveMode(), static_cast<GLint>(first), static_cast<GLsizei>(vertexCount));
}
void GLDevice::drawElementsInstanced(u32 indexCount, GfxDataType indexType, u32 byteOffset, u32 instanceCount) {
if (!isDeviceUsable()) return;
prepareVertexState();
- glDrawElementsInstanced(glPrimitiveMode(), static_cast<GLsizei>(indexCount), toGLDataType(indexType),
+ glDrawElementsInstanced(primitiveMode(), static_cast<GLsizei>(indexCount), toGLDataType(indexType),
reinterpret_cast<const void*>(static_cast<uintptr_t>(byteOffset)),
static_cast<GLsizei>(instanceCount));
}
diff --git a/src/esengine/renderer/rhi/GLDevice.hpp b/src/esengine/renderer/rhi/GLDevice.hpp
index 0c1237c51..a90662325 100644
--- a/src/esengine/renderer/rhi/GLDevice.hpp
+++ b/src/esengine/renderer/rhi/GLDevice.hpp
@@ -132,7 +132,7 @@ protected:
void backendDeleteVertexLayout(u32 id) override;
void backendSetPipeline(u32 id, const PipelineDesc& desc) override;
/** The GL primitive mode of the bound pipeline's topology. */
- u32 glPrimitiveMode() const;
+ u32 primitiveMode() const;
void backendInvalidatePipelineCache() override;
bool backendCreateFramebuffer(u32 id, const FramebufferDesc& desc) override;
diff --git a/tools/goldenProjects.mjs b/tools/goldenProjects.mjs
index 580a312f5..96a5309f3 100644
--- a/tools/goldenProjects.mjs
+++ b/tools/goldenProjects.mjs
@@ -92,6 +92,24 @@ export const CENSUS_FLOOR = '0.60.0';
* that does not exist, and release notes are a different act. Theirs is ungated.
*/
export const SHIPPED = {
+ "Material graphs have a Tiling & Offset node.": { notCertifiable: "Material graph authoring and compilation are covered by the pipeline tests, editor authoring checks and mat-graph pixel fixture; no golden project carries a material graph asset." },
+ "Material graph editor polish.": { notCertifiable: "Material graph authoring and compilation are covered by the pipeline tests, editor authoring checks and mat-graph pixel fixture; no golden project carries a material graph asset." },
+ "Material graphs have switches, a live preview and extract-to-subgraph.": { notCertifiable: "Material graph authoring and compilation are covered by the pipeline tests, editor authoring checks and mat-graph pixel fixture; no golden project carries a material graph asset." },
+ "Material graphs can bend a mesh and its shadow.": { notCertifiable: "Material graph authoring and compilation are covered by the pipeline tests, editor authoring checks and mat-graph pixel fixture; no golden project carries a material graph asset." },
+ "Material graphs can output a standard PBR surface.": { notCertifiable: "Material graph authoring and compilation are covered by the pipeline tests, editor authoring checks and mat-graph pixel fixture; no golden project carries a material graph asset." },
+ "Material graphs can use other graphs as nodes.": { notCertifiable: "Material graph authoring and compilation are covered by the pipeline tests, editor authoring checks and mat-graph pixel fixture; no golden project carries a material graph asset." },
+ "The Plugins panel shows conflicts and what disabling removes.": { notCertifiable: "Editor presentation and authoring changes are covered by the editor tests and authoring checks; a packaged game cannot observe the editor interface." },
+ "The Agent panel is redrawn.": { notCertifiable: "Editor presentation and authoring changes are covered by the editor tests and authoring checks; a packaged game cannot observe the editor interface." },
+ "The Project Health panel is redrawn.": { notCertifiable: "Editor presentation and authoring changes are covered by the editor tests and authoring checks; a packaged game cannot observe the editor interface." },
+ "The UI debugger is redrawn.": { notCertifiable: "Editor presentation and authoring changes are covered by the editor tests and authoring checks; a packaged game cannot observe the editor interface." },
+ "The UI Widgets palette is a searchable, grouped list.": { notCertifiable: "Editor presentation and authoring changes are covered by the editor tests and authoring checks; a packaged game cannot observe the editor interface." },
+ "The World panel is a table of cells beside the Content Browser.": { notCertifiable: "Editor presentation and authoring changes are covered by the editor tests and authoring checks; a packaged game cannot observe the editor interface." },
+ "The Spine preview, running-game inspection and the Game panel states are redrawn.": { notCertifiable: "Editor presentation and authoring changes are covered by the editor tests and authoring checks; a packaged game cannot observe the editor interface." },
+ "The lighting, history, scatter, plugins and string table panels are redrawn.": { notCertifiable: "Editor presentation and authoring changes are covered by the editor tests and authoring checks; a packaged game cannot observe the editor interface." },
+ "The script, material and behavior-tree graph editors are redrawn.": { notCertifiable: "Editor presentation and authoring changes are covered by the editor tests and authoring checks; a packaged game cannot observe the editor interface." },
+ "The sequencer and the sound event editor are redrawn.": { notCertifiable: "Editor presentation and authoring changes are covered by the editor tests and authoring checks; a packaged game cannot observe the editor interface." },
+ "The profiler and the frame debugger are redrawn.": { notCertifiable: "Editor presentation and authoring changes are covered by the editor tests and authoring checks; a packaged game cannot observe the editor interface." },
+ "Editor polish and plugin compatibility.": { notCertifiable: "Editor panel layout and example plugin compatibility are covered by editor tests and check-examples; a packaged game loads no editor plugin." },
"Audio demo exercises authored sound events.":
{ notCertifiable: "the example's sources are validated by check-examples; no packaged-frame act can decide which clip a seeded selection picked" },
"The Lighting panel names the scene's environment and binds it.":
diff --git a/tools/releaseNotes.mjs b/tools/releaseNotes.mjs
index 6de0c2414..4dce013cb 100644
--- a/tools/releaseNotes.mjs
+++ b/tools/releaseNotes.mjs
@@ -28,6 +28,17 @@ export const NOTES_FLOOR = 'v0.65.0';
* the reader recognises anyway.
*/
export const NOTED = {
+ "fix(examples): the Scene Report plugin example claims editors from 0.33 on instead of only 0.33.x, so it loads": {"note":"Editor polish and plugin compatibility."},
+ "fix(editor): the UI debugger's focus summary keeps its spacing": {"note":"Editor polish and plugin compatibility."},
+ "fix(editor): a controller binding in the Controllers panel is two lines, so a long field name is read whole": {"note":"Editor polish and plugin compatibility."},
+ "fix(editor): warnings in the World, Plugins, Inspector and Build panels are plain lines rather than tinted cards": {"note":"Editor polish and plugin compatibility."},
+ "fix(editor): the lighting panel's warnings are a line with an amber dot, not a card": {"note":"Editor polish and plugin compatibility."},
+ "fix(editor): the lighting panel's bake counts say less so the pinned footer stays short": {"note":"Editor polish and plugin compatibility."},
+ "feat(editor): the material graph editor shows the Tiling & Offset node": {"note":"Material graphs have a Tiling & Offset node."},
+ "fix(editor): a subgraph node wires in the type it returns and a multi-selection drags as one": {"note":"Material graph editor polish."},
+ "feat(editor): the material graph editor previews the graph live, has a Switch node and extracts a selection into a subgraph": {"note":"Material graphs have switches, a live preview and extract-to-subgraph."},
+ "feat(editor): the material graph output node shows the vertex offset port and its bounds field": {"note":"Material graphs can bend a mesh and its shadow."},
+ "fix(editor): the collision layer's material fields take the board's heading, flat inputs and hint": {"note":"Editor polish and plugin compatibility."},
'feat(editor): a string table imports and exports as an Excel or CSV sheet, merged by key, with the problems checked before it leaves':
{ note: 'Strings go to and from Excel.' },
'feat(editor): the input map editor captures the next key, shows key caps and flags inputs shared between actions':