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.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
feat(render): a view can shade its meshes as clay or albedo, and the viewport's Show menu offers both
yhhca47a63c72af
diff --git a/.github/workflows/build.yml b/.github/workflows/build.ymlindex d327df9c7..07c2b9def 100644--- a/.github/workflows/build.yml+++ b/.github/workflows/build.yml@@ -30,7 +30,7 @@ env:test_hierarchy_links test_entity_activity test_transform_traversal test_ui_tree test_tween_activitytest_shader_device test_draw_params test_per_draw_blocks test_texture_fb test_buffer_devicetest_compressed_format test_batch_builder test_skeletal_batch_color test_boundary_span test_webgpu_device- test_clip_depth test_sort_key test_sprite_mask_range test_sprite_draw_mode test_shadow_atlas test_particle_shapes test_lod_selection test_hdr_format test_probe_store test_occlusion_view test_reflection_store+ test_clip_depth test_sort_key test_sprite_mask_range test_sprite_draw_mode test_shadow_atlas test_particle_shapes test_lod_selection test_view_shading test_hdr_format test_probe_store test_occlusion_view test_reflection_storetest_text_edit test_render_graph test_device_loss test_physics_interpolationtest_bitmap_font test_texture_cache test_material_shader_lifetime test_mesh_recovery test_aot_host test_aot_conformancetest_touch_streamdiff --git a/CHANGELOG.md b/CHANGELOG.mdindex ca2c60834..eca0223ed 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -16,7 +16,7 @@ published separately; it ships inside the editor.### 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 shows the vertices it moves as dots from blue to red; convex colliders now draw with the other 3D colliders.+- **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 shows the vertices it moves as dots from blue to red; convex colliders now draw with the other 3D colliders. 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 material's preview is a real shape.** Selecting a material shows it on a sphere, cube or plane (lit materials open on the sphere, sprite shaders on the plane), over a dark, checker or light background, with a sample image for shaders that sample a texture; the choice is remembered per kind. The header carries the ball as its icon and the name with a faint extension, the shader is a plain section with a link to make it unique, and the Content Browser's material thumbnails use the same preview. The engine's offscreen preview target now has a depth buffer, so a mesh drawn there is no longer drawn inside out.- **The 2D animation editors are redrawn.** In the sprite animation editor the view's tools float over its corner, playback and the timeline are one panel, frame events are flags on an event track (click one to rename, move or remove it), the frame source folds into a strip that opens on an empty clip, and frame rate, loop and Save no longer appear a second time in the inspector. The animator controller shows states as cards with their clip and speed, wires between a pair of states run side by side with a pill for the condition (dashed when it waits for the exit time), and its inspector puts the selected state or transition first, with the controller's layers, typed parameters and a folded constraints section below.- **The tile editor matches its design.** The layer and tileset menus sit on the raised surface, a picked tile has a 2px frame and shows its id on hover, the brush column shows the tile id, the replace dialog's button says Replace, and the tileset inspector shows one-way and trigger as switches, the layer opacity is a slim slider, and a collision layer's friction and bounce fields are flat with their own heading.diff --git a/desktop b/desktopindex 5f6ebb7f6..29201339c 160000--- a/desktop+++ b/desktop@@ -1 +1 @@-Subproject commit 5f6ebb7f611a470521060be185343ed9e72eb604+Subproject commit 29201339c8812c32a9c71cc3a323d7ec6128485adiff --git a/fixtures/scenes/view-shading.esscene b/fixtures/scenes/view-shading.esscenenew file mode 100644index 000000000..b5590ea10--- /dev/null+++ b/fixtures/scenes/view-shading.esscene@@ -0,0 +1,147 @@+{+ "version": 4,+ "name": "MeshBuiltin",+ "entities": [+ {+ "id": 0,+ "name": "Camera",+ "parent": null,+ "children": [],+ "visible": true,+ "components": [+ {+ "type": "Transform",+ "data": {+ "position": {+ "x": 0,+ "y": 0,+ "z": 300+ }+ }+ },+ {+ "type": "Camera",+ "data": {+ "projectionType": 1,+ "orthoSize": 150,+ "isActive": true,+ "priority": 0+ }+ }+ ]+ },+ {+ "id": 1,+ "name": "Cube",+ "parent": null,+ "children": [],+ "visible": true,+ "components": [+ {+ "type": "Transform",+ "data": {+ "position": {+ "x": -75,+ "y": 0,+ "z": 0+ },+ "rotation": {+ "x": 0,+ "y": -0.3826834324,+ "z": 0,+ "w": 0.9238795325+ }+ }+ },+ {+ "type": "MeshRenderer",+ "data": {+ "mesh": "builtin:cube",+ "color": {+ "r": 0.9,+ "g": 0.2,+ "b": 0.2,+ "a": 1+ },+ "lit": true,+ "opaque": true,+ "cullBackfaces": true,+ "enabled": true+ }+ }+ ]+ },+ {+ "id": 2,+ "name": "Sphere",+ "parent": null,+ "children": [],+ "visible": true,+ "components": [+ {+ "type": "Transform",+ "data": {+ "position": {+ "x": 75,+ "y": 0,+ "z": 0+ }+ }+ },+ {+ "type": "MeshRenderer",+ "data": {+ "mesh": "builtin:sphere",+ "color": {+ "r": 0.2,+ "g": 0.75,+ "b": 0.3,+ "a": 1+ },+ "lit": true,+ "opaque": true,+ "cullBackfaces": true,+ "enabled": true+ }+ }+ ]+ },+ {+ "id": 3,+ "name": "Sun",+ "parent": null,+ "children": [],+ "visible": true,+ "components": [+ {+ "type": "Transform",+ "data": {+ "position": {+ "x": 0,+ "y": 0,+ "z": 0+ }+ }+ },+ {+ "type": "Light",+ "data": {+ "type": 1,+ "color": {+ "r": 1,+ "g": 1,+ "b": 1,+ "a": 1+ },+ "intensity": 1,+ "direction": {+ "x": -0.4142135624,+ "y": 0+ },+ "directionZ": -1+ }+ }+ ]+ }+ ]+}\ No newline at end of filediff --git a/sdk/etc/index.api.md b/sdk/etc/index.api.mdindex 2780ac3c8..1092b0b9c 100644--- a/sdk/etc/index.api.md+++ b/sdk/etc/index.api.md@@ -1,7 +1,7 @@# API surface — esengine/index<!-- Generated by tools/api-surface.mjs — do not edit. Run --update to accept changes. -->-Symbols: 115 public · 109 beta · 1599 experimental · 3 deprecated+Symbols: 115 public · 109 beta · 1604 experimental · 3 deprecated## ABI_LAYOUT_HASH — const @experimental```@@ -2710,6 +2710,11 @@ EditorViewDataEditorViewLightingData```+## DEFAULT_EDITOR_VIEW_SHADING — const @experimental+```+EditorViewShadingData+```+## DEFAULT_FACING_COSINE — const @experimental```0.2@@ -3481,6 +3486,16 @@ showSky: booleanskyIntensity: number```+## EditorViewShading — const @experimental+```+ResourceDef<EditorViewShadingData>+```++## EditorViewShadingData — interface @experimental+```+mode: ViewShading+```+## EditorWorkPlane — interface @experimental```normal: WorldAxis@@ -7058,7 +7073,7 @@ UIElement = 7## Renderer — const @experimental```-{ init(width: number, height: number): void; resize(width: number, height: number): void; beginFrame(elapsedSec?: number): void; updateTransforms(registry: { _cpp: CppRegistry; }): void; begin(viewProjection: Float32Array, target?: RenderTargetHandle, clearFlags?: number, clearColor?: { x: number; y: number; z: number; w: number; }, clearRect?: { x: number; y: number; w: number; h: number; }): void; flush(): void; end(): void; endFrame(): void; hasScreenOverlay(): boolean; beginScreenOverlay(projection: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): void; submitScreenOverlay(registry: { _cpp: CppRegistry; }): void; endScreenOverlay(target?: RenderTargetHandle): void; submitAll(registry: { _cpp: CppRegistry; }, vpX: number, vpY: number, vpW: number, vpH: number): void; setStage(stage: RenderStage): void; createRenderTarget(width: number, height: number, flags?: number): RenderTargetHandle; releaseRenderTarget(handle: RenderTargetHandle): void; getTargetTexture(handle: RenderTargetHandle): number; getTargetDepthTexture(handle: RenderTargetHandle): number; setClearColor(r: number, g: number, b: number, a: number): void; setViewport(x: number, y: number, w: number, h: number): void; setYSortLayers(mask: number): void; setDepthLayers(mask: number): void; setCullingMask(mask: number): void; setViewId(view: number): void; lodInspect(view: number, entity: number): LodDecision | null; setLodPreview(view: number, entity: number, level: number | null): void; lightStatus(entity: number): LightStatus | null; shadowStatus(entity: number): ShadowStatus | null; setTextureParams(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void; measureBitmapText(fontHandle: number, text: string, fontSize: number, spacing: number): { width: number; height: number; }; getStats(): RenderStats; captureNextFrame(): void; getCapturedData(): FrameCaptureData | null; hasCapturedData(): boolean; replayToDrawCall(drawCallIndex: number): void; getSnapshotImageData(): Promise<ImageData | null>; snapshotMatchesCapture(): boolean; }+{ init(width: number, height: number): void; resize(width: number, height: number): void; beginFrame(elapsedSec?: number): void; updateTransforms(registry: { _cpp: CppRegistry; }): void; begin(viewProjection: Float32Array, target?: RenderTargetHandle, clearFlags?: number, clearColor?: { x: number; y: number; z: number; w: number; }, clearRect?: { x: number; y: number; w: number; h: number; }): void; flush(): void; end(): void; endFrame(): void; hasScreenOverlay(): boolean; beginScreenOverlay(projection: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): void; submitScreenOverlay(registry: { _cpp: CppRegistry; }): void; endScreenOverlay(target?: RenderTargetHandle): void; submitAll(registry: { _cpp: CppRegistry; }, vpX: number, vpY: number, vpW: number, vpH: number): void; setStage(stage: RenderStage): void; createRenderTarget(width: number, height: number, flags?: number): RenderTargetHandle; releaseRenderTarget(handle: RenderTargetHandle): void; getTargetTexture(handle: RenderTargetHandle): number; getTargetDepthTexture(handle: RenderTargetHandle): number; setClearColor(r: number, g: number, b: number, a: number): void; setViewport(x: number, y: number, w: number, h: number): void; setYSortLayers(mask: number): void; setDepthLayers(mask: number): void; setCullingMask(mask: number): void; setViewId(view: number): void; lodInspect(view: number, entity: number): LodDecision | null; setLodPreview(view: number, entity: number, level: number | null): void; setViewShading(view: number, mode: ViewShading): void; lightStatus(entity: number): LightStatus | null; shadowStatus(entity: number): ShadowStatus | null; setTextureParams(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void; measureBitmapText(fontHandle: number, text: string, fontSize: number, spacing: number): { width: number; height: number; }; getStats(): RenderStats; captureNextFrame(): void; getCapturedData(): FrameCaptureData | null; hasCapturedData(): boolean; replayToDrawCall(drawCallIndex: number): void; getSnapshotImageData(): Promise<ImageData | null>; snapshotMatchesCapture(): boolean; }```## ReplayReport — interface @experimental@@ -10056,6 +10071,11 @@ playbackRate: number | undefinedvolume: number | undefined```+## ViewShading — type @experimental+```+'shaded' | 'clay' | 'albedo'+```+## Viewport — interface @experimental```h: number@@ -11456,6 +11476,11 @@ DragPlugin(data: EditorViewLightingData): boolean```+## editorViewShadingMode — function @experimental+```+(data: EditorViewShadingData, viewActive: boolean): ViewShading+```+## editorViewStandoff — function @experimental```(view: EditorViewData): numberdiff --git a/sdk/etc/index.native.api.md b/sdk/etc/index.native.api.mdindex 016251732..e79ef75a3 100644--- a/sdk/etc/index.native.api.md+++ b/sdk/etc/index.native.api.md@@ -1,7 +1,7 @@# API surface — esengine/index.native<!-- Generated by tools/api-surface.mjs — do not edit. Run --update to accept changes. -->-Symbols: 115 public · 114 beta · 1618 experimental · 3 deprecated+Symbols: 115 public · 114 beta · 1623 experimental · 3 deprecated## ABI_LAYOUT_HASH — const @experimental```@@ -2718,6 +2718,11 @@ EditorViewDataEditorViewLightingData```+## DEFAULT_EDITOR_VIEW_SHADING — const @experimental+```+EditorViewShadingData+```+## DEFAULT_FACING_COSINE — const @experimental```0.2@@ -3489,6 +3494,16 @@ showSky: booleanskyIntensity: number```+## EditorViewShading — const @experimental+```+ResourceDef<EditorViewShadingData>+```++## EditorViewShadingData — interface @experimental+```+mode: ViewShading+```+## EditorWorkPlane — interface @experimental```normal: WorldAxis@@ -7271,7 +7286,7 @@ UIElement = 7## Renderer — const @experimental```-{ init(width: number, height: number): void; resize(width: number, height: number): void; beginFrame(elapsedSec?: number): void; updateTransforms(registry: { _cpp: CppRegistry; }): void; begin(viewProjection: Float32Array, target?: RenderTargetHandle, clearFlags?: number, clearColor?: { x: number; y: number; z: number; w: number; }, clearRect?: { x: number; y: number; w: number; h: number; }): void; flush(): void; end(): void; endFrame(): void; hasScreenOverlay(): boolean; beginScreenOverlay(projection: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): void; submitScreenOverlay(registry: { _cpp: CppRegistry; }): void; endScreenOverlay(target?: RenderTargetHandle): void; submitAll(registry: { _cpp: CppRegistry; }, vpX: number, vpY: number, vpW: number, vpH: number): void; setStage(stage: RenderStage): void; createRenderTarget(width: number, height: number, flags?: number): RenderTargetHandle; releaseRenderTarget(handle: RenderTargetHandle): void; getTargetTexture(handle: RenderTargetHandle): number; getTargetDepthTexture(handle: RenderTargetHandle): number; setClearColor(r: number, g: number, b: number, a: number): void; setViewport(x: number, y: number, w: number, h: number): void; setYSortLayers(mask: number): void; setDepthLayers(mask: number): void; setCullingMask(mask: number): void; setViewId(view: number): void; lodInspect(view: number, entity: number): LodDecision | null; setLodPreview(view: number, entity: number, level: number | null): void; lightStatus(entity: number): LightStatus | null; shadowStatus(entity: number): ShadowStatus | null; setTextureParams(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void; measureBitmapText(fontHandle: number, text: string, fontSize: number, spacing: number): { width: number; height: number; }; getStats(): RenderStats; captureNextFrame(): void; getCapturedData(): FrameCaptureData | null; hasCapturedData(): boolean; replayToDrawCall(drawCallIndex: number): void; getSnapshotImageData(): Promise<ImageData | null>; snapshotMatchesCapture(): boolean; }+{ init(width: number, height: number): void; resize(width: number, height: number): void; beginFrame(elapsedSec?: number): void; updateTransforms(registry: { _cpp: CppRegistry; }): void; begin(viewProjection: Float32Array, target?: RenderTargetHandle, clearFlags?: number, clearColor?: { x: number; y: number; z: number; w: number; }, clearRect?: { x: number; y: number; w: number; h: number; }): void; flush(): void; end(): void; endFrame(): void; hasScreenOverlay(): boolean; beginScreenOverlay(projection: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): void; submitScreenOverlay(registry: { _cpp: CppRegistry; }): void; endScreenOverlay(target?: RenderTargetHandle): void; submitAll(registry: { _cpp: CppRegistry; }, vpX: number, vpY: number, vpW: number, vpH: number): void; setStage(stage: RenderStage): void; createRenderTarget(width: number, height: number, flags?: number): RenderTargetHandle; releaseRenderTarget(handle: RenderTargetHandle): void; getTargetTexture(handle: RenderTargetHandle): number; getTargetDepthTexture(handle: RenderTargetHandle): number; setClearColor(r: number, g: number, b: number, a: number): void; setViewport(x: number, y: number, w: number, h: number): void; setYSortLayers(mask: number): void; setDepthLayers(mask: number): void; setCullingMask(mask: number): void; setViewId(view: number): void; lodInspect(view: number, entity: number): LodDecision | null; setLodPreview(view: number, entity: number, level: number | null): void; setViewShading(view: number, mode: ViewShading): void; lightStatus(entity: number): LightStatus | null; shadowStatus(entity: number): ShadowStatus | null; setTextureParams(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void; measureBitmapText(fontHandle: number, text: string, fontSize: number, spacing: number): { width: number; height: number; }; getStats(): RenderStats; captureNextFrame(): void; getCapturedData(): FrameCaptureData | null; hasCapturedData(): boolean; replayToDrawCall(drawCallIndex: number): void; getSnapshotImageData(): Promise<ImageData | null>; snapshotMatchesCapture(): boolean; }```## ReplayReport — interface @experimental@@ -10269,6 +10284,11 @@ playbackRate: number | undefinedvolume: number | undefined```+## ViewShading — type @experimental+```+'shaded' | 'clay' | 'albedo'+```+## Viewport — interface @experimental```h: number@@ -11709,6 +11729,11 @@ DragPlugin(data: EditorViewLightingData): boolean```+## editorViewShadingMode — function @experimental+```+(data: EditorViewShadingData, viewActive: boolean): ViewShading+```+## editorViewStandoff — function @experimental```(view: EditorViewData): numberdiff --git a/sdk/etc/index.node.api.md b/sdk/etc/index.node.api.mdindex 33ccf152b..02788b420 100644--- a/sdk/etc/index.node.api.md+++ b/sdk/etc/index.node.api.md@@ -1,7 +1,7 @@# API surface — esengine/index.node<!-- Generated by tools/api-surface.mjs — do not edit. Run --update to accept changes. -->-Symbols: 115 public · 111 beta · 1598 experimental · 3 deprecated+Symbols: 115 public · 111 beta · 1603 experimental · 3 deprecated## ANCHOR_AXES — const @experimental```@@ -2705,6 +2705,11 @@ EditorViewDataEditorViewLightingData```+## DEFAULT_EDITOR_VIEW_SHADING — const @experimental+```+EditorViewShadingData+```+## DEFAULT_FACING_COSINE — const @experimental```0.2@@ -3476,6 +3481,16 @@ showSky: booleanskyIntensity: number```+## EditorViewShading — const @experimental+```+ResourceDef<EditorViewShadingData>+```++## EditorViewShadingData — interface @experimental+```+mode: ViewShading+```+## EditorWorkPlane — interface @experimental```normal: WorldAxis@@ -7053,7 +7068,7 @@ UIElement = 7## Renderer — const @experimental```-{ init(width: number, height: number): void; resize(width: number, height: number): void; beginFrame(elapsedSec?: number): void; updateTransforms(registry: { _cpp: CppRegistry; }): void; begin(viewProjection: Float32Array, target?: RenderTargetHandle, clearFlags?: number, clearColor?: { x: number; y: number; z: number; w: number; }, clearRect?: { x: number; y: number; w: number; h: number; }): void; flush(): void; end(): void; endFrame(): void; hasScreenOverlay(): boolean; beginScreenOverlay(projection: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): void; submitScreenOverlay(registry: { _cpp: CppRegistry; }): void; endScreenOverlay(target?: RenderTargetHandle): void; submitAll(registry: { _cpp: CppRegistry; }, vpX: number, vpY: number, vpW: number, vpH: number): void; setStage(stage: RenderStage): void; createRenderTarget(width: number, height: number, flags?: number): RenderTargetHandle; releaseRenderTarget(handle: RenderTargetHandle): void; getTargetTexture(handle: RenderTargetHandle): number; getTargetDepthTexture(handle: RenderTargetHandle): number; setClearColor(r: number, g: number, b: number, a: number): void; setViewport(x: number, y: number, w: number, h: number): void; setYSortLayers(mask: number): void; setDepthLayers(mask: number): void; setCullingMask(mask: number): void; setViewId(view: number): void; lodInspect(view: number, entity: number): LodDecision | null; setLodPreview(view: number, entity: number, level: number | null): void; lightStatus(entity: number): LightStatus | null; shadowStatus(entity: number): ShadowStatus | null; setTextureParams(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void; measureBitmapText(fontHandle: number, text: string, fontSize: number, spacing: number): { width: number; height: number; }; getStats(): RenderStats; captureNextFrame(): void; getCapturedData(): FrameCaptureData | null; hasCapturedData(): boolean; replayToDrawCall(drawCallIndex: number): void; getSnapshotImageData(): Promise<ImageData | null>; snapshotMatchesCapture(): boolean; }+{ init(width: number, height: number): void; resize(width: number, height: number): void; beginFrame(elapsedSec?: number): void; updateTransforms(registry: { _cpp: CppRegistry; }): void; begin(viewProjection: Float32Array, target?: RenderTargetHandle, clearFlags?: number, clearColor?: { x: number; y: number; z: number; w: number; }, clearRect?: { x: number; y: number; w: number; h: number; }): void; flush(): void; end(): void; endFrame(): void; hasScreenOverlay(): boolean; beginScreenOverlay(projection: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): void; submitScreenOverlay(registry: { _cpp: CppRegistry; }): void; endScreenOverlay(target?: RenderTargetHandle): void; submitAll(registry: { _cpp: CppRegistry; }, vpX: number, vpY: number, vpW: number, vpH: number): void; setStage(stage: RenderStage): void; createRenderTarget(width: number, height: number, flags?: number): RenderTargetHandle; releaseRenderTarget(handle: RenderTargetHandle): void; getTargetTexture(handle: RenderTargetHandle): number; getTargetDepthTexture(handle: RenderTargetHandle): number; setClearColor(r: number, g: number, b: number, a: number): void; setViewport(x: number, y: number, w: number, h: number): void; setYSortLayers(mask: number): void; setDepthLayers(mask: number): void; setCullingMask(mask: number): void; setViewId(view: number): void; lodInspect(view: number, entity: number): LodDecision | null; setLodPreview(view: number, entity: number, level: number | null): void; setViewShading(view: number, mode: ViewShading): void; lightStatus(entity: number): LightStatus | null; shadowStatus(entity: number): ShadowStatus | null; setTextureParams(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void; measureBitmapText(fontHandle: number, text: string, fontSize: number, spacing: number): { width: number; height: number; }; getStats(): RenderStats; captureNextFrame(): void; getCapturedData(): FrameCaptureData | null; hasCapturedData(): boolean; replayToDrawCall(drawCallIndex: number): void; getSnapshotImageData(): Promise<ImageData | null>; snapshotMatchesCapture(): boolean; }```## ReplayReport — interface @experimental@@ -10051,6 +10066,11 @@ playbackRate: number | undefinedvolume: number | undefined```+## ViewShading — type @experimental+```+'shaded' | 'clay' | 'albedo'+```+## Viewport — interface @experimental```h: number@@ -11451,6 +11471,11 @@ DragPlugin(data: EditorViewLightingData): boolean```+## editorViewShadingMode — function @experimental+```+(data: EditorViewShadingData, viewActive: boolean): ViewShading+```+## editorViewStandoff — function @experimental```(view: EditorViewData): numberdiff --git a/sdk/etc/minigame.api.md b/sdk/etc/minigame.api.mdindex 4334be837..db1d9eb0e 100644--- a/sdk/etc/minigame.api.md+++ b/sdk/etc/minigame.api.md@@ -1,7 +1,7 @@# API surface — esengine/minigame<!-- Generated by tools/api-surface.mjs — do not edit. Run --update to accept changes. -->-Symbols: 115 public · 109 beta · 1620 experimental · 3 deprecated+Symbols: 115 public · 109 beta · 1625 experimental · 3 deprecated## ANCHOR_AXES — const @experimental```@@ -2705,6 +2705,11 @@ EditorViewDataEditorViewLightingData```+## DEFAULT_EDITOR_VIEW_SHADING — const @experimental+```+EditorViewShadingData+```+## DEFAULT_FACING_COSINE — const @experimental```0.2@@ -3476,6 +3481,16 @@ showSky: booleanskyIntensity: number```+## EditorViewShading — const @experimental+```+ResourceDef<EditorViewShadingData>+```++## EditorViewShadingData — interface @experimental+```+mode: ViewShading+```+## EditorWorkPlane — interface @experimental```normal: WorldAxis@@ -7346,7 +7361,7 @@ UIElement = 7## Renderer — const @experimental```-{ init(width: number, height: number): void; resize(width: number, height: number): void; beginFrame(elapsedSec?: number): void; updateTransforms(registry: { _cpp: CppRegistry; }): void; begin(viewProjection: Float32Array, target?: RenderTargetHandle, clearFlags?: number, clearColor?: { x: number; y: number; z: number; w: number; }, clearRect?: { x: number; y: number; w: number; h: number; }): void; flush(): void; end(): void; endFrame(): void; hasScreenOverlay(): boolean; beginScreenOverlay(projection: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): void; submitScreenOverlay(registry: { _cpp: CppRegistry; }): void; endScreenOverlay(target?: RenderTargetHandle): void; submitAll(registry: { _cpp: CppRegistry; }, vpX: number, vpY: number, vpW: number, vpH: number): void; setStage(stage: RenderStage): void; createRenderTarget(width: number, height: number, flags?: number): RenderTargetHandle; releaseRenderTarget(handle: RenderTargetHandle): void; getTargetTexture(handle: RenderTargetHandle): number; getTargetDepthTexture(handle: RenderTargetHandle): number; setClearColor(r: number, g: number, b: number, a: number): void; setViewport(x: number, y: number, w: number, h: number): void; setYSortLayers(mask: number): void; setDepthLayers(mask: number): void; setCullingMask(mask: number): void; setViewId(view: number): void; lodInspect(view: number, entity: number): LodDecision | null; setLodPreview(view: number, entity: number, level: number | null): void; lightStatus(entity: number): LightStatus | null; shadowStatus(entity: number): ShadowStatus | null; setTextureParams(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void; measureBitmapText(fontHandle: number, text: string, fontSize: number, spacing: number): { width: number; height: number; }; getStats(): RenderStats; captureNextFrame(): void; getCapturedData(): FrameCaptureData | null; hasCapturedData(): boolean; replayToDrawCall(drawCallIndex: number): void; getSnapshotImageData(): Promise<ImageData | null>; snapshotMatchesCapture(): boolean; }+{ init(width: number, height: number): void; resize(width: number, height: number): void; beginFrame(elapsedSec?: number): void; updateTransforms(registry: { _cpp: CppRegistry; }): void; begin(viewProjection: Float32Array, target?: RenderTargetHandle, clearFlags?: number, clearColor?: { x: number; y: number; z: number; w: number; }, clearRect?: { x: number; y: number; w: number; h: number; }): void; flush(): void; end(): void; endFrame(): void; hasScreenOverlay(): boolean; beginScreenOverlay(projection: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): void; submitScreenOverlay(registry: { _cpp: CppRegistry; }): void; endScreenOverlay(target?: RenderTargetHandle): void; submitAll(registry: { _cpp: CppRegistry; }, vpX: number, vpY: number, vpW: number, vpH: number): void; setStage(stage: RenderStage): void; createRenderTarget(width: number, height: number, flags?: number): RenderTargetHandle; releaseRenderTarget(handle: RenderTargetHandle): void; getTargetTexture(handle: RenderTargetHandle): number; getTargetDepthTexture(handle: RenderTargetHandle): number; setClearColor(r: number, g: number, b: number, a: number): void; setViewport(x: number, y: number, w: number, h: number): void; setYSortLayers(mask: number): void; setDepthLayers(mask: number): void; setCullingMask(mask: number): void; setViewId(view: number): void; lodInspect(view: number, entity: number): LodDecision | null; setLodPreview(view: number, entity: number, level: number | null): void; setViewShading(view: number, mode: ViewShading): void; lightStatus(entity: number): LightStatus | null; shadowStatus(entity: number): ShadowStatus | null; setTextureParams(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void; measureBitmapText(fontHandle: number, text: string, fontSize: number, spacing: number): { width: number; height: number; }; getStats(): RenderStats; captureNextFrame(): void; getCapturedData(): FrameCaptureData | null; hasCapturedData(): boolean; replayToDrawCall(drawCallIndex: number): void; getSnapshotImageData(): Promise<ImageData | null>; snapshotMatchesCapture(): boolean; }```## ReplayReport — interface @experimental@@ -10350,6 +10365,11 @@ playbackRate: number | undefinedvolume: number | undefined```+## ViewShading — type @experimental+```+'shaded' | 'clay' | 'albedo'+```+## Viewport — interface @experimental```h: number@@ -11755,6 +11775,11 @@ DragPlugin(data: EditorViewLightingData): boolean```+## editorViewShadingMode — function @experimental+```+(data: EditorViewShadingData, viewActive: boolean): ViewShading+```+## editorViewStandoff — function @experimental```(view: EditorViewData): numberdiff --git a/sdk/etc/wasm.api.md b/sdk/etc/wasm.api.mdindex a8bdcf87b..94f3c10cf 100644--- a/sdk/etc/wasm.api.md+++ b/sdk/etc/wasm.api.md@@ -491,6 +491,7 @@ renderer_setStage: (stage: number) => voidrenderer_setTextureParams: (textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number) => voidrenderer_setViewId: ((view: number) => void) | undefinedrenderer_setViewLighting: ((mode: number, rotationDegrees: number, keyIntensity: number, fillIntensity: number, skyIntensity: number, showSky: boolean) => void) | undefined+renderer_setViewShading: ((view: number, mode: number) => void) | undefinedrenderer_setViewport: (x: number, y: number, w: number, h: number) => voidrenderer_setYSortLayers: ((mask: number) => void) | undefinedrenderer_shadowStatus: ((entity: number, outPtr: number) => number) | undefineddiff --git a/sdk/etc/wechat.api.md b/sdk/etc/wechat.api.mdindex b8ee237bc..7aaad9d2d 100644--- a/sdk/etc/wechat.api.md+++ b/sdk/etc/wechat.api.md@@ -1,7 +1,7 @@# API surface — esengine/wechat<!-- Generated by tools/api-surface.mjs — do not edit. Run --update to accept changes. -->-Symbols: 115 public · 109 beta · 1611 experimental · 3 deprecated+Symbols: 115 public · 109 beta · 1616 experimental · 3 deprecated## ANCHOR_AXES — const @experimental```@@ -2705,6 +2705,11 @@ EditorViewDataEditorViewLightingData```+## DEFAULT_EDITOR_VIEW_SHADING — const @experimental+```+EditorViewShadingData+```+## DEFAULT_FACING_COSINE — const @experimental```0.2@@ -3476,6 +3481,16 @@ showSky: booleanskyIntensity: number```+## EditorViewShading — const @experimental+```+ResourceDef<EditorViewShadingData>+```++## EditorViewShadingData — interface @experimental+```+mode: ViewShading+```+## EditorWorkPlane — interface @experimental```normal: WorldAxis@@ -7060,7 +7075,7 @@ UIElement = 7## Renderer — const @experimental```-{ init(width: number, height: number): void; resize(width: number, height: number): void; beginFrame(elapsedSec?: number): void; updateTransforms(registry: { _cpp: CppRegistry; }): void; begin(viewProjection: Float32Array, target?: RenderTargetHandle, clearFlags?: number, clearColor?: { x: number; y: number; z: number; w: number; }, clearRect?: { x: number; y: number; w: number; h: number; }): void; flush(): void; end(): void; endFrame(): void; hasScreenOverlay(): boolean; beginScreenOverlay(projection: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): void; submitScreenOverlay(registry: { _cpp: CppRegistry; }): void; endScreenOverlay(target?: RenderTargetHandle): void; submitAll(registry: { _cpp: CppRegistry; }, vpX: number, vpY: number, vpW: number, vpH: number): void; setStage(stage: RenderStage): void; createRenderTarget(width: number, height: number, flags?: number): RenderTargetHandle; releaseRenderTarget(handle: RenderTargetHandle): void; getTargetTexture(handle: RenderTargetHandle): number; getTargetDepthTexture(handle: RenderTargetHandle): number; setClearColor(r: number, g: number, b: number, a: number): void; setViewport(x: number, y: number, w: number, h: number): void; setYSortLayers(mask: number): void; setDepthLayers(mask: number): void; setCullingMask(mask: number): void; setViewId(view: number): void; lodInspect(view: number, entity: number): LodDecision | null; setLodPreview(view: number, entity: number, level: number | null): void; lightStatus(entity: number): LightStatus | null; shadowStatus(entity: number): ShadowStatus | null; setTextureParams(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void; measureBitmapText(fontHandle: number, text: string, fontSize: number, spacing: number): { width: number; height: number; }; getStats(): RenderStats; captureNextFrame(): void; getCapturedData(): FrameCaptureData | null; hasCapturedData(): boolean; replayToDrawCall(drawCallIndex: number): void; getSnapshotImageData(): Promise<ImageData | null>; snapshotMatchesCapture(): boolean; }+{ init(width: number, height: number): void; resize(width: number, height: number): void; beginFrame(elapsedSec?: number): void; updateTransforms(registry: { _cpp: CppRegistry; }): void; begin(viewProjection: Float32Array, target?: RenderTargetHandle, clearFlags?: number, clearColor?: { x: number; y: number; z: number; w: number; }, clearRect?: { x: number; y: number; w: number; h: number; }): void; flush(): void; end(): void; endFrame(): void; hasScreenOverlay(): boolean; beginScreenOverlay(projection: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): void; submitScreenOverlay(registry: { _cpp: CppRegistry; }): void; endScreenOverlay(target?: RenderTargetHandle): void; submitAll(registry: { _cpp: CppRegistry; }, vpX: number, vpY: number, vpW: number, vpH: number): void; setStage(stage: RenderStage): void; createRenderTarget(width: number, height: number, flags?: number): RenderTargetHandle; releaseRenderTarget(handle: RenderTargetHandle): void; getTargetTexture(handle: RenderTargetHandle): number; getTargetDepthTexture(handle: RenderTargetHandle): number; setClearColor(r: number, g: number, b: number, a: number): void; setViewport(x: number, y: number, w: number, h: number): void; setYSortLayers(mask: number): void; setDepthLayers(mask: number): void; setCullingMask(mask: number): void; setViewId(view: number): void; lodInspect(view: number, entity: number): LodDecision | null; setLodPreview(view: number, entity: number, level: number | null): void; setViewShading(view: number, mode: ViewShading): void; lightStatus(entity: number): LightStatus | null; shadowStatus(entity: number): ShadowStatus | null; setTextureParams(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void; measureBitmapText(fontHandle: number, text: string, fontSize: number, spacing: number): { width: number; height: number; }; getStats(): RenderStats; captureNextFrame(): void; getCapturedData(): FrameCaptureData | null; hasCapturedData(): boolean; replayToDrawCall(drawCallIndex: number): void; getSnapshotImageData(): Promise<ImageData | null>; snapshotMatchesCapture(): boolean; }```## ReplayReport — interface @experimental@@ -10058,6 +10073,11 @@ playbackRate: number | undefinedvolume: number | undefined```+## ViewShading — type @experimental+```+'shaded' | 'clay' | 'albedo'+```+## Viewport — interface @experimental```h: number@@ -11482,6 +11502,11 @@ DragPlugin(data: EditorViewLightingData): boolean```+## editorViewShadingMode — function @experimental+```+(data: EditorViewShadingData, viewActive: boolean): ViewShading+```+## editorViewStandoff — function @experimental```(view: EditorViewData): numberdiff --git a/sdk/src/camera/CameraPlugin.ts b/sdk/src/camera/CameraPlugin.tsindex 631b82c95..cd0e5c18d 100644--- a/sdk/src/camera/CameraPlugin.ts+++ b/sdk/src/camera/CameraPlugin.ts@@ -23,6 +23,8 @@ import { ProjectionType, SceneOwner, ClearFlags } from '../ecs/component';import { canvasRootEntities } from '../ui/core/canvas-roots';import { uiLayoutRect, computeEffectiveOrthoSize, EDITOR_VIEW_ENTITY, type CanvasScale } from './uiLayoutRect';import { EditorViewLighting, DEFAULT_EDITOR_VIEW_LIGHTING, pushEditorViewLighting } from './EditorViewLighting';+import { EditorViewShading, DEFAULT_EDITOR_VIEW_SHADING, pushEditorViewShading } from './EditorViewShading';+import type { ViewShading } from '../render/renderer';import { EditorView, DEFAULT_EDITOR_VIEW, editorViewStandoff, editorViewClipFar, editorViewClipNear, type EditorViewData } from './EditorView';import { ScreenScaling, DEFAULT_SCREEN_SCALING, SCREEN_FIT_OFF } from './ScreenScaling';import { planPresent, viewportPixels, RenderResolution } from './presentPlan';@@ -786,6 +788,9 @@ export function cameraPlugin(// Its lighting is the view's too: untouched, the scene renders by its own.app.insertResource(EditorViewLighting, { ...DEFAULT_EDITOR_VIEW_LIGHTING });let lastViewLighting = '';+ // And its shading: clay or albedo for the eye alone, shaded for everything else.+ app.insertResource(EditorViewShading, { ...DEFAULT_EDITOR_VIEW_SHADING });+ let lastViewShading: ViewShading | null = null;// The camera director: by default it just tracks the active camera;// games call setViewTarget(app, entity, {time, curve}) to blend, or// shakeCamera(app, {...}) to shake. Fresh state (own arrays) per App.@@ -855,6 +860,10 @@ export function cameraPlugin(module, app.getResource(EditorViewLighting),app.hasResource(EditorView) && app.getResource(EditorView).active,lastViewLighting);+ lastViewShading = pushEditorViewShading(+ app.getResource(EditorViewShading),+ app.hasResource(EditorView) && app.getResource(EditorView).active,+ lastViewShading);pipeline.beginFrame(elapsed);app.measureFrameScope('render.updateTransforms', () =>Renderer.updateTransforms({ _cpp: cppRegistry }));diff --git a/sdk/src/camera/EditorViewShading.ts b/sdk/src/camera/EditorViewShading.tsnew file mode 100644index 000000000..27a8361ee--- /dev/null+++ b/sdk/src/camera/EditorViewShading.ts@@ -0,0 +1,43 @@+// SPDX-License-Identifier: Apache-2.0+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team+/**+ * @file EditorViewShading.ts+ * @brief How the editor viewport shades its meshes — view state, beside EditorViewLighting.+ *+ * @details Clay and albedo are questions asked of the scene while it is authored: "is this+ * the right shape", "is this the right texture". Like the view's lighting it is+ * no scene entity and is never serialized, and it reaches the engine only while+ * the editor view is the one drawing, so play mode and a packaged build always+ * render each mesh as authored.+ */+import { defineResource } from '../ecs/resource';+import { Renderer, type ViewShading } from '../render/renderer';+import { EDITOR_VIEW_ENTITY } from './uiLayoutRect';++export interface EditorViewShadingData {+ mode: ViewShading;+}++export const DEFAULT_EDITOR_VIEW_SHADING: EditorViewShadingData = { mode: 'shaded' };++export const EditorViewShading = defineResource<EditorViewShadingData>(+ { ...DEFAULT_EDITOR_VIEW_SHADING }, 'EditorViewShading');++/** The mode the engine is to use: an inactive view (play mode, a shipped game) carries no override. */+export function editorViewShadingMode(data: EditorViewShadingData, viewActive: boolean): ViewShading {+ return viewActive ? data.mode : 'shaded';+}++/**+ * Pushes the view's shading to the engine, once per change. Returns the mode it last+ * pushed, so a caller skips the crossing while nothing moved.+ */+export function pushEditorViewShading(+ data: EditorViewShadingData,+ viewActive: boolean,+ last: ViewShading | null,+): ViewShading {+ const mode = editorViewShadingMode(data, viewActive);+ if (mode !== last) Renderer.setViewShading(EDITOR_VIEW_ENTITY >>> 0, mode);+ return mode;+}diff --git a/sdk/src/core-render.ts b/sdk/src/core-render.tsindex 804de1435..da37dc93f 100644--- a/sdk/src/core-render.ts+++ b/sdk/src/core-render.ts@@ -48,6 +48,8 @@ export { EditorView, DEFAULT_EDITOR_VIEW, editorViewHalfHeight, editorViewHalfExexport type { EditorViewData, ScreenAxis, EditorViewBasis, EditorWorkPlane, WorldAxis } from './camera/EditorView';export { EditorViewLighting, DEFAULT_EDITOR_VIEW_LIGHTING, EDITOR_EXPOSURE_RANGE, editorViewLightingIsOverriding, resetEditorViewLighting, editorViewLightingArgs, studioPreviewReport } from './camera/EditorViewLighting';export type { EditorViewLightingData, EditorLightingMode, StudioPreviewReport, SkyUnavailable, SceneDark } from './camera/EditorViewLighting';+export { EditorViewShading, DEFAULT_EDITOR_VIEW_SHADING, editorViewShadingMode } from './camera/EditorViewShading';+export type { EditorViewShadingData } from './camera/EditorViewShading';export { ScreenScaling, DEFAULT_SCREEN_SCALING, SCREEN_FIT_OFF } from './camera/ScreenScaling';export type { ScreenScalingData } from './camera/ScreenScaling';export { EditorGrid, DEFAULT_EDITOR_GRID } from './camera/EditorGrid';@@ -175,6 +177,7 @@ export {type RenderTargetHandle,type RenderStats,type LodDecision,+ type ViewShading,type LightStatus,type ShadowStatus,} from './render/renderer';diff --git a/sdk/src/ecs/bridge/nativeBindings.ts b/sdk/src/ecs/bridge/nativeBindings.tsindex abdb790ae..9801d9a1d 100644--- a/sdk/src/ecs/bridge/nativeBindings.ts+++ b/sdk/src/ecs/bridge/nativeBindings.ts@@ -205,6 +205,8 @@ export const RENDERER_OPTIONAL_BINDINGS = {* no editor, and the game it does run is unaffected either way. */lodInspect: 'es_renderer_lodInspect',setLodPreview: 'es_renderer_setLodPreview',+ /** How a view shades its meshes — clay, albedo or as authored. An editor's view mode. */+ setViewShading: 'es_renderer_setViewShading',/** Which lights the cap turned away — an editor's question, like the two above. */lightStatus: 'es_renderer_lightStatus',shadowStatus: 'es_renderer_shadowStatus',diff --git a/sdk/src/ecs/bridge/nativeEngineApi.generated.ts b/sdk/src/ecs/bridge/nativeEngineApi.generated.tsindex 94ef3908c..b0a16fdae 100644--- a/sdk/src/ecs/bridge/nativeEngineApi.generated.ts+++ b/sdk/src/ecs/bridge/nativeEngineApi.generated.ts@@ -200,6 +200,7 @@ export interface NativeEngineApi {renderer_setLodPreview?(view: number, entity: number, level: number): void;renderer_setQualityBudgets?(atlasSize: number, cellSize: number, cascades: number, particleLimit: number): void;renderer_setShadowDistance?(distance: number): void;+ renderer_setViewShading?(view: number, mode: 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;@@ -500,6 +501,7 @@ export function createNativeEngineApi(bind('renderer_setLodPreview', 'es_renderer_setLodPreview', false);bind('renderer_setQualityBudgets', 'es_renderer_setQualityBudgets', false);bind('renderer_setShadowDistance', 'es_renderer_setShadowDistance', false);+ bind('renderer_setViewShading', 'es_renderer_setViewShading', false);bind('renderer_setStage', 'es_renderer_setStage', false);bind('renderer_setTextureParams', 'es_renderer_setTextureParams', false);bind('renderer_setViewId', 'es_renderer_setViewId', false);diff --git a/sdk/src/ecs/bridge/nativeRenderer.ts b/sdk/src/ecs/bridge/nativeRenderer.tsindex e3932fa45..2014abae3 100644--- a/sdk/src/ecs/bridge/nativeRenderer.ts+++ b/sdk/src/ecs/bridge/nativeRenderer.ts@@ -183,6 +183,10 @@ export function createNativeRendererBackend((fn as (v: number, e: number, l: number) => void)(view >>> 0, entity >>> 0, level ?? -1);}},+ setViewShading: (view, mode): void => {+ const fn = scope[RENDERER_OPTIONAL_BINDINGS.setViewShading];+ if (typeof fn === 'function') (fn as (v: number, m: number) => void)(view >>> 0, mode);+ },getStats: (): RenderStats => {const read = (name: string): number => {const fn = scope[name];diff --git a/sdk/src/render/renderer.ts b/sdk/src/render/renderer.tsindex f41f9ebd1..24f82509d 100644--- a/sdk/src/render/renderer.ts+++ b/sdk/src/render/renderer.ts@@ -75,6 +75,7 @@ export interface RendererBackend {setViewId(view: number): void;lodInspect(view: number, entity: number): LodDecision | null;setLodPreview(view: number, entity: number, level: number | null): void;+ setViewShading(view: number, mode: number): void;lightStatus(entity: number): LightStatus | null;shadowStatus(entity: number): ShadowStatus | null;getStats(): RenderStats;@@ -135,6 +136,11 @@ export interface LightStatus {* explanation of a level has to be the frame's own, and a second selector written* beside this one would be free to disagree with the picture on screen.*/+/** How a view shades its meshes. @experimental */+export type ViewShading = 'shaded' | 'clay' | 'albedo';++const VIEW_SHADING_CODE: Record<ViewShading, number> = { shaded: 0, clay: 1, albedo: 2 };+export interface LodDecision {/** The level drawn, or `null` when the object was small enough to be culled. */level: number | null;@@ -254,6 +260,7 @@ function wasmBackend(m: ESEngineModule): RendererBackend {},setLodPreview: (view, entity, level) =>m.renderer_setLodPreview?.(view >>> 0, entity >>> 0, level ?? -1),+ setViewShading: (view, mode) => m.renderer_setViewShading?.(view >>> 0, mode),shadowStatus: (entity) => {if (!m.renderer_shadowStatus || !lightStatusPtr) return null;if (!m.renderer_shadowStatus(entity >>> 0, lightStatusPtr)) return null;@@ -683,6 +690,17 @@ export const Renderer = {backend?.setLodPreview(view, entity, level);},+ /**+ * Shade `view`'s meshes as `mode` says instead of as authored. @experimental+ *+ * View state, like a LOD preview. Clay is one neutral lit surface, albedo the base+ * colour with no light and no material; a shadow map is unaffected and a host that+ * predates the mode ignores the call.+ */+ setViewShading(view: number, mode: ViewShading): void {+ backend?.setViewShading(view, VIEW_SHADING_CODE[mode]);+ },+/*** What the light cap did to `entity` last frame, or null before any frame has* collected lights. @experimentaldiff --git a/sdk/src/wasm.ts b/sdk/src/wasm.tsindex 6726ef837..852f72719 100644--- a/sdk/src/wasm.ts+++ b/sdk/src/wasm.ts@@ -672,6 +672,7 @@ export interface ESEngineModule {renderer_setViewId?(view: number): void;renderer_lodInspect?(view: number, entity: number, outPtr: number): number;renderer_setLodPreview?(view: number, entity: number, level: number): void;+ renderer_setViewShading?(view: number, mode: number): void;renderer_lightStatus?(entity: number, outPtr: number): number;renderer_shadowStatus?(entity: number, outPtr: number): number;renderer_setColorSpace?(linear: number): void;diff --git a/sdk/tests/camera-commit.test.ts b/sdk/tests/camera-commit.test.tsindex 557c5d284..1f514cd0b 100644--- a/sdk/tests/camera-commit.test.ts+++ b/sdk/tests/camera-commit.test.ts@@ -45,7 +45,7 @@ describe('the camera a frame was drawn with', () => {setStage: () => {}, setViewport: () => {},setYSortLayers: () => {}, setDepthLayers: () => {}, setCullingMask: () => {},setViewId: () => {},- lodInspect: () => null, setLodPreview: () => {}, lightStatus: () => null, shadowStatus: () => null,+ lodInspect: () => null, setLodPreview: () => {}, setViewShading: () => {}, lightStatus: () => null, shadowStatus: () => null,getStats: () => ({ drawCalls: 0, triangles: 0, sprites: 0, text: 0, skeletal: 0, meshes: 0, culled: 0 }),};}diff --git a/sdk/tests/camera-render-order.test.ts b/sdk/tests/camera-render-order.test.tsindex 7ff721962..435d91424 100644--- a/sdk/tests/camera-render-order.test.ts+++ b/sdk/tests/camera-render-order.test.ts@@ -65,7 +65,7 @@ describe('render order: transforms resolve before cameras are read', () => {setStage: () => {}, setViewport: () => {},setYSortLayers: () => {}, setDepthLayers: () => {}, setCullingMask: () => {},setViewId: () => {},- lodInspect: () => null, setLodPreview: () => {}, lightStatus: () => null, shadowStatus: () => null,+ lodInspect: () => null, setLodPreview: () => {}, setViewShading: () => {}, lightStatus: () => null, shadowStatus: () => null,getStats: () => ({ drawCalls: 0, triangles: 0, sprites: 0, text: 0, skeletal: 0, meshes: 0, culled: 0 }),};}diff --git a/sdk/tests/editor-view-shading.test.ts b/sdk/tests/editor-view-shading.test.tsnew file mode 100644index 000000000..35c050473--- /dev/null+++ b/sdk/tests/editor-view-shading.test.ts@@ -0,0 +1,34 @@+// SPDX-License-Identifier: Apache-2.0+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team+/**+ * The editor view's shading is VIEW state: clay and albedo reach the engine only while the+ * editor eye is the one drawing, through the one per-view door, and only when it changes.+ */+import { describe, it, expect, vi, beforeEach } from 'vitest';++const calls = vi.hoisted(() => [] as [number, string][]);+vi.mock('../src/render/renderer', () => ({+ Renderer: { setViewShading: (view: number, mode: string) => { calls.push([view, mode]); } },+}));++import { DEFAULT_EDITOR_VIEW_SHADING, editorViewShadingMode, pushEditorViewShading } from '../src/camera/EditorViewShading';+import { EDITOR_VIEW_ENTITY } from '../src/camera/uiLayoutRect';++beforeEach(() => { calls.length = 0; });++describe('what reaches the engine', () => {+ it('is the authored look whenever the editor eye is not drawing', () => {+ expect(editorViewShadingMode({ mode: 'clay' }, false)).toBe('shaded');+ expect(editorViewShadingMode({ mode: 'albedo' }, true)).toBe('albedo');+ expect(DEFAULT_EDITOR_VIEW_SHADING.mode).toBe('shaded');+ });++ it('is addressed to the editor view and crosses once per change', () => {+ let last = pushEditorViewShading({ mode: 'clay' }, true, null);+ last = pushEditorViewShading({ mode: 'clay' }, true, last);+ last = pushEditorViewShading({ mode: 'clay' }, false, last);+ last = pushEditorViewShading({ mode: 'clay' }, false, last);+ expect(last).toBe('shaded');+ expect(calls).toEqual([[EDITOR_VIEW_ENTITY >>> 0, 'clay'], [EDITOR_VIEW_ENTITY >>> 0, 'shaded']]);+ });+});diff --git a/src/esengine/bindings/RendererBindings.cpp b/src/esengine/bindings/RendererBindings.cppindex 494191c9e..b893159f1 100644--- a/src/esengine/bindings/RendererBindings.cpp+++ b/src/esengine/bindings/RendererBindings.cpp@@ -1093,6 +1093,15 @@ void renderer_setLodPreview(u32 view, u32 entity, i32 level) {g_renderFrame->setLodPreview(view, Entity::fromRaw(entity), held);}+void renderer_setViewShading(u32 view, i32 mode) {+ if (!g_renderFrame) return;+ // An unknown mode is the authored look, not a crash: a newer editor may ask for+ // a mode this engine does not have.+ const ShadingMode known = (mode > 0 && mode < static_cast<i32>(kShadingModeCount))+ ? static_cast<ShadingMode>(mode) : ShadingMode::Shaded;+ g_renderFrame->setViewShading(view, known);+}+i32 renderer_lightStatus(u32 entity, uintptr_t outPtr) {auto* out = boundarySpanMut<f32>(outPtr, 9, "renderer_lightStatus.out");if (!out) return 0;diff --git a/src/esengine/bindings/RendererBindings.hpp b/src/esengine/bindings/RendererBindings.hppindex d4a42fc89..69d5920dd 100644--- a/src/esengine/bindings/RendererBindings.hpp+++ b/src/esengine/bindings/RendererBindings.hpp@@ -228,6 +228,13 @@ i32 renderer_lodInspect(u32 view, u32 entity, uintptr_t outPtr);*/void renderer_setLodPreview(u32 view, u32 entity, i32 level);+/**+ * @brief Shade a view's meshes as authored (0), as neutral clay (1) or as flat albedo (2).+ * @details View state, like the LOD preview beside it: the same scene drawn through+ * another view keeps its own look. Out-of-range modes mean authored.+ */+void renderer_setViewShading(u32 view, i32 mode);+/*** @brief What the light cap did to @p entity last frame, into nine floats at* @p outPtr: accepted, refusal, limit, requested, refusedCount, then whetherdiff --git a/src/esengine/bindings/WebSDKEntry.cpp b/src/esengine/bindings/WebSDKEntry.cppindex 9f60f63d0..90d6f3ba9 100644--- a/src/esengine/bindings/WebSDKEntry.cpp+++ b/src/esengine/bindings/WebSDKEntry.cpp@@ -772,6 +772,7 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {emscripten::function("renderer_setViewId", &esengine::renderer_setViewId);emscripten::function("renderer_lodInspect", &esengine::renderer_lodInspect);emscripten::function("renderer_setLodPreview", &esengine::renderer_setLodPreview);+ emscripten::function("renderer_setViewShading", &esengine::renderer_setViewShading);emscripten::function("renderer_lightStatus", &esengine::renderer_lightStatus);emscripten::function("renderer_shadowStatus", &esengine::renderer_shadowStatus);emscripten::function("renderer_setColorSpace", &esengine::renderer_setColorSpace);diff --git a/src/esengine/renderer/RenderTypePlugin.hpp b/src/esengine/renderer/RenderTypePlugin.hppindex 5eed7df18..c3ce35be7 100644--- a/src/esengine/renderer/RenderTypePlugin.hpp+++ b/src/esengine/renderer/RenderTypePlugin.hpp@@ -8,6 +8,7 @@#include "./frame/OcclusionView.hpp"#include "./lod/LodSelection.hpp"#include "./lod/LodViewState.hpp"+#include "./frame/ViewShading.hpp"#include "./frame/FrameConstants.hpp"#include "./draw/RenderItem.hpp"#include "./draw/DrawCommand.hpp"@@ -320,6 +321,13 @@ struct RenderCollectContext {lod::SelectionCounts* counts = nullptr;};LodView lod;++ /**+ * @brief How the meshes of THIS collect are shaded. Shaded unless the view asked+ * for another mode; a collect that is not a camera's (the shadow map) leaves+ * it alone, because a depth write has no colour to override.+ */+ ShadingMode shading = ShadingMode::Shaded;};/** @brief Decomposes @p transform and returns its world position shifted toward thediff --git a/src/esengine/renderer/frame/RenderFrame.cpp b/src/esengine/renderer/frame/RenderFrame.cppindex cb3608734..8764cc786 100644--- a/src/esengine/renderer/frame/RenderFrame.cpp+++ b/src/esengine/renderer/frame/RenderFrame.cpp@@ -2137,6 +2137,7 @@ void RenderFrame::collectAll(ecs::Registry& registry) {// through a view matrix puts a HUD wherever the view happens to be looking.collectCtx.screen_ui = screen_domain_;collectCtx.lod = {view_id_, &lod_view_state_, &lod_counts_};+ collectCtx.shading = view_shading_.get(view_id_);// Only the camera collect. The shadow collect above builds its own context and// leaves this null: what a player cannot see still casts, and a caster dropped// because the camera cannot see IT takes its shadow off the ground with it.diff --git a/src/esengine/renderer/frame/RenderFrame.hpp b/src/esengine/renderer/frame/RenderFrame.hppindex 77e2b0cec..19979dfb7 100644--- a/src/esengine/renderer/frame/RenderFrame.hpp+++ b/src/esengine/renderer/frame/RenderFrame.hpp@@ -318,6 +318,18 @@ public:/** @brief How many (view, entity) pairs are held up for inspection. */usize lodPreviewCount() const { return lod_view_state_.previewCount(); }+ /**+ * @brief Shade @p view's meshes as @p mode says instead of as authored.+ *+ * @details View state, like a LOD preview: what the scene IS is the same+ * everywhere, and what a creator wants to look at is decided by the+ * window they are looking through.+ */+ void setViewShading(u32 view, ShadingMode mode) { view_shading_.set(view, mode); }++ /** @brief The mode @p view asked for; Shaded when it never did. */+ ShadingMode viewShading(u32 view) const { return view_shading_.get(view); }+/*** @brief What each caster asked the shadow atlas for last frame, and what it got.*@@ -561,6 +573,7 @@ private:u32 view_id_ = 0;lod::LodViewState lod_view_state_;+ ViewShading view_shading_;lod::SelectionCounts lod_counts_;std::unordered_map<SkeletalPreviewId, Unique<SkeletalPreview>> skeletal_previews_;diff --git a/src/esengine/renderer/frame/ViewShading.hpp b/src/esengine/renderer/frame/ViewShading.hppnew file mode 100644index 000000000..18a9cb868--- /dev/null+++ b/src/esengine/renderer/frame/ViewShading.hpp@@ -0,0 +1,56 @@+// SPDX-License-Identifier: Apache-2.0+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team+/**+ * @file ViewShading.hpp+ * @brief How a view shades the meshes it draws: as authored, as plain clay, or flat albedo.+ */+#pragma once++#include "../../core/Types.hpp"++#include <unordered_map>++namespace esengine {++/**+ * @brief What a mesh is drawn WITH in a view, whatever its own material says.+ *+ * @details A debugging question, not a style: shape is asked of clay, texture of albedo.+ * View state, so a camera preview drawn in the same frame keeps the authored+ * look. Only the camera collect reads it; a shadow map draws depth either way.+ */+enum class ShadingMode : u8 {+ /// Each mesh as authored: its material, its textures, its light.+ Shaded = 0,+ /// One neutral matte surface, lit: form and silhouette without anyone's colours.+ Clay = 1,+ /// Base colour and texture with no light and no material: what was painted.+ Albedo = 2,+};++inline constexpr u8 kShadingModeCount = 3;++/**+ * @brief The mode each view asked for. A view that never asked is Shaded, which is+ * why a frame with nothing set costs a hash lookup per collect and nothing else.+ */+class ViewShading {+public:+ void set(u32 view, ShadingMode mode) {+ if (mode == ShadingMode::Shaded) modes_.erase(view);+ else modes_[view] = mode;+ }++ ShadingMode get(u32 view) const {+ const auto it = modes_.find(view);+ return it == modes_.end() ? ShadingMode::Shaded : it->second;+ }++ /// Views holding a non-default mode, for a criterion that checks nothing leaked.+ usize count() const { return modes_.size(); }++private:+ std::unordered_map<u32, ShadingMode> modes_;+};++} // namespace esenginediff --git a/src/esengine/renderer/plugins/MeshPlugin.cpp b/src/esengine/renderer/plugins/MeshPlugin.cppindex 4a2f5f673..1a700e11e 100644--- a/src/esengine/renderer/plugins/MeshPlugin.cpp+++ b/src/esengine/renderer/plugins/MeshPlugin.cpp@@ -261,6 +261,25 @@ u32 meshVariant(bool normals, bool lit, bool normalMapped, bool skinned, bool de* so the caller does not resolve it twice. A second copy of these facts* drifts the day the key gains another.*/+/**+ * @brief What a mesh is drawn as when its view overrides the look: the authored+ * material, normal map and (for clay) texture and colour are set aside, and+ * the plain description left drives the same draw path as any other mesh.+ * @details One place, so a mode cannot be half-applied: the variant, the draw key and+ * the instance record all read the SAME overridden description.+ */+void applyShading(ecs::MeshRenderer& mesh, ShadingMode mode) {+ mesh.material = 0;+ mesh.normalMap = {};+ if (mode == ShadingMode::Clay) {+ mesh.texture = {};+ mesh.color = glm::vec4(0.74f, 0.74f, 0.76f, 1.0f);+ mesh.lit = true;+ } else {+ mesh.lit = false;+ }+}+struct MeshDrawKeys {u32 variant = 0;u32 normalTextureId = 0;@@ -475,6 +494,9 @@ void MeshPlugin::collect(RenderCollectContext& collect_ctx) {const bool shadowDepth = ctx.purpose == RenderPurpose::ShadowDepth;u32 litProgram = 0;+ // The mesh as this view's mode describes it; one object reused across the walk.+ const ShadingMode shading = shadowDepth ? ShadingMode::Shaded : collect_ctx.shading;+ ecs::MeshRenderer shaded;// Accumulated, not scoped per mesh: a ScopeTimer pair per phase per entity// puts its own cost inside the number it reports. One clock read per@@ -492,7 +514,14 @@ void MeshPlugin::collect(RenderCollectContext& collect_ctx) {for (auto entity : meshView) {++walked;- const auto& mesh = meshView.get<ecs::MeshRenderer>(entity);+ const auto& authored = meshView.get<ecs::MeshRenderer>(entity);+ const ecs::MeshRenderer* described = &authored;+ if (shading != ShadingMode::Shaded) {+ shaded = authored;+ applyShading(shaded, shading);+ described = &shaded;+ }+ const auto& mesh = *described;// Empty indices no longer mean "nothing to draw": a resident mesh keeps// its geometry on the GPU and its inline payload deliberately empty.if (!mesh.enabled || (mesh.indices.empty() && !mesh.mesh.isValid())) continue;diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txtindex eea701de5..616b2f1f4 100644--- a/tests/CMakeLists.txt+++ b/tests/CMakeLists.txt@@ -328,6 +328,14 @@ target_include_directories(test_lod_selection PRIVATE)add_test(NAME test_lod_selection COMMAND test_lod_selection)+# How a view shades its meshes: Shaded unless it asked, and no entry left once it goes back.+add_executable(test_view_shading renderer/test_view_shading.cpp)+target_include_directories(test_view_shading PRIVATE+ ${CMAKE_SOURCE_DIR}/src+ ${CMAKE_SOURCE_DIR}/third_party/glm+)+add_test(NAME test_view_shading COMMAND test_view_shading)+# Which volume holds a point, and what it says there. Header-only, so it runs# without a device — the pixel gates say a draw came out the wrong colour, this# says whether the read left the box, took the wrong volume, or accepted a griddiff --git a/tests/renderer/test_view_shading.cpp b/tests/renderer/test_view_shading.cppnew file mode 100644index 000000000..b8377823e--- /dev/null+++ b/tests/renderer/test_view_shading.cpp@@ -0,0 +1,42 @@+// What a view's shading mode is: a value the view holds, Shaded for a view that never+// asked, and nothing at all once it goes back. Header-only, so no device is needed — the+// pixel side (clay is neutral, albedo ignores light) is the editor's to look at.++#include "esengine/renderer/frame/ViewShading.hpp"++#include <cstdio>++using namespace esengine;++static int g_failures = 0;+#define CHECK(cond, msg) \+ do { \+ if (!(cond)) { std::printf("FAIL: %s\n", msg); ++g_failures; } \+ else { std::printf("ok: %s\n", msg); } \+ } while (0)++int main() {+ ViewShading shading;+ CHECK(shading.get(7) == ShadingMode::Shaded, "a view that never asked is drawn as authored");+ CHECK(shading.count() == 0, "an untouched store holds nothing");++ shading.set(7, ShadingMode::Clay);+ shading.set(9, ShadingMode::Albedo);+ CHECK(shading.get(7) == ShadingMode::Clay, "a view keeps the mode it asked for");+ CHECK(shading.get(9) == ShadingMode::Albedo, "and another view keeps its own");+ CHECK(shading.get(8) == ShadingMode::Shaded, "a third is unaffected by either");+ CHECK(shading.count() == 2, "two views hold a mode");++ shading.set(7, ShadingMode::Shaded);+ CHECK(shading.get(7) == ShadingMode::Shaded, "asking for the authored look goes back to it");+ CHECK(shading.count() == 1, "and leaves no entry behind, so nothing leaks over a session");++ CHECK(kShadingModeCount == 3, "the modes the bindings accept are the ones the enum declares");++ if (g_failures) {+ std::printf("%d failure(s)\n", g_failures);+ return 1;+ }+ std::printf("all view shading checks passed\n");+ return 0;+}diff --git a/tools/check-render-scenes.mjs b/tools/check-render-scenes.mjsindex b854734b4..27b305f2c 100644--- a/tools/check-render-scenes.mjs+++ b/tools/check-render-scenes.mjs@@ -44,7 +44,7 @@ for (const s of SCENES) {const asserts = s.env.ESTELLA_VERIFY_EXPECT || s.env.ESTELLA_VERIFY_COUNT|| s.env.ESTELLA_VERIFY_DEVICE_LOSS === 'roundtrip'|| s.env.ESTELLA_VERIFY_SEAM- || s.env.ESTELLA_VERIFY_GRID || s.env.ESTELLA_VERIFY_STUDIO || s.env.ESTELLA_VERIFY_PREVIEW+ || s.env.ESTELLA_VERIFY_GRID || s.env.ESTELLA_VERIFY_STUDIO || s.env.ESTELLA_VERIFY_SHADING || s.env.ESTELLA_VERIFY_PREVIEW|| s.env.ESTELLA_VERIFY_MESH_PREVIEW || s.env.ESTELLA_VERIFY_DEPTH_LAYERS|| s.env.ESTELLA_VERIFY_COUNTERS || s.env.ESTELLA_VERIFY_COUNTERS_MAX || s.env.ESTELLA_VERIFY_FRAME_DEBUG || s.env.ESTELLA_VERIFY_EDGE || s.env.ESTELLA_VERIFY_CUTOUT_EDGE || s.env.ESTELLA_VERIFY_MINIFIED || s.env.ESTELLA_VERIFY_TWINS|| s.env.ESTELLA_VERIFY_DRAW_CALLS || s.env.ESTELLA_VERIFY_NINE_SLICEdiff --git a/tools/releaseNotes.mjs b/tools/releaseNotes.mjsindex 5e3ce3b18..280cedf2a 100644--- a/tools/releaseNotes.mjs+++ b/tools/releaseNotes.mjs@@ -112,6 +112,8 @@ export const NOTED = {{ note: 'Gizmos are redrawn.' },"feat(editor): the Show menu draws wireframe on every mesh, a chosen bone's skin weights as coloured dots, and convex colliders are listed with the other 3D colliders":{ note: 'Gizmos are redrawn.' },+ "feat(render): a view can shade its meshes as clay or albedo, and the viewport's Show menu offers both":+ { note: 'Gizmos are redrawn.' },'feat(editor): an asset header names its kind and size, and a segmented switch is used only when its words fit':{ note: "An asset's header names its kind and size." },"feat(editor): asset inspectors take the board's finish — a card preview, ruled key-value rows, tinted actions, a kind icon in the header":diff --git a/tools/render-host/host.ts b/tools/render-host/host.tsindex b8c115666..070035f01 100644--- a/tools/render-host/host.ts+++ b/tools/render-host/host.ts@@ -22,7 +22,7 @@ import {getComponent, DeviceStatus, getDeviceStatus, getDeviceLostReport, recoverDevice,getContextLossGuardInfo, decodeImagePixels, captureFramePixels, captureFrame, replayDraw, BatchBreak,RenderTexture, Camera, Sprite,- EditorViewLighting, EditorView, EditorGrid, installEditorGrid, editorViewHalfHeight, setEditorViewHalfHeight,+ EditorViewLighting, EditorViewShading, EditorView, EditorGrid, installEditorGrid, editorViewHalfHeight, setEditorViewHalfHeight,ProfileRecorder, AnimatorController, Timeline, onDeviceRestored, Schedule, defineSystem,textureImportSettingsFrom,} from 'esengine';@@ -684,6 +684,15 @@ const api = {Object.assign(lighting, spec);},+ /** How the editor view shades its meshes: 'shaded', 'clay' or 'albedo'. View state,+ * like the lighting above, so it wakes the editor eye the frame is drawn through. */+ setViewShading(mode: 'shaded' | 'clay' | 'albedo'): void {+ if (!app) throw new Error('set_view_shading before boot');+ const view = app.getResource(EditorView);+ if (!view.active) { seedEditorViewFromScene(); view.active = true; }+ app.getResource(EditorViewShading).mode = mode;+ },+/** The reference grid. Enabling seeds and activates the eye it draws through,* because this host boots with that eye inactive. */setGrid(enabled: boolean, spacing?: number): void {diff --git a/tools/render-host/run.mjs b/tools/render-host/run.mjsindex 515c43daf..32d485465 100644--- a/tools/render-host/run.mjs+++ b/tools/render-host/run.mjs@@ -31,6 +31,7 @@* ESTELLA_VERIFY_PICK hit-test a viewport point, asserting the entity (JSON)* ESTELLA_VERIFY_ORBIT turn the editor eye before capture ("yaw,pitch" degrees)* ESTELLA_VERIFY_STUDIO the editor view's studio lighting and exposure (JSON: see the block)+ * ESTELLA_VERIFY_SHADING the editor view's clay and albedo shading (any non-empty value; see the block)* ESTELLA_VERIFY_COUNTERS engine counters the drawn frame must report (JSON)* ESTELLA_VERIFY_COUNTERS_MAX counters the frame must stay UNDER — a budget (JSON)* ESTELLA_VERIFY_FRAME_DEBUG capture the frame and replay it (the frame debugger)@@ -219,14 +220,15 @@ function finish(result, server) {// The studio gate's own last frame is the scene's, which for the scene with no light is// black on purpose; what proves a frame was drawn there is the studio frame it measured.const studioDrew = result.studio?.ok === true && (result.studio.S?.litShare ?? 0) > 0;- const renderedOk = (result.capture?.rendered ?? false) || uniformByDesign || studioDrew;+ const shadingDrew = result.shading?.ok === true && (result.shading.C?.litShare ?? 0) > 0;+ const renderedOk = (result.capture?.rendered ?? false) || uniformByDesign || studioDrew || shadingDrew;// A scene that could not load an asset it names draws a frame nobody declared, so// its pixels answer a different question — say which asset instead.const assetsOk = (result.missingAssets?.length ?? 0) === 0;const ok = result.ok && renderedOk && assetsOk && (result.expect?.ok ?? true) && (result.twins?.ok ?? true) && (result.count?.ok ?? true) &&(result.seam?.ok ?? true) && (result.nineSlice?.ok ?? true) &&(result.resize?.ok ?? true) && (result.preview?.ok ?? true) &&- (result.meshPreview?.ok ?? true) && (result.grid?.ok ?? true) && (result.studio?.ok ?? true) &&+ (result.meshPreview?.ok ?? true) && (result.grid?.ok ?? true) && (result.studio?.ok ?? true) && (result.shading?.ok ?? true) &&(result.draws?.ok ?? true) && (result.counters?.ok ?? true) && (result.frameDebug?.ok ?? true) && (result.edge?.ok ?? true) && (result.cutoutEdge?.ok ?? true) && (result.minified?.ok ?? true) &&(result.roundtrip?.ok ?? true) && deviceLossOk && meshOk && pickOk;const why = assetsOk ? '' : `: could not load ${result.missingAssets.join(', ')}`;@@ -1131,7 +1133,48 @@ app.whenReady().then(async () => {: (S && dStudio.differing > 200);studio = { A, S, dStudio, back, sky, exp, ok: Boolean(darkOk) && (!spec.studio || back.max === 0) && (!sky || sky.ok) && (!exp || exp.ok) };}- finish({ ok: true, studio, entityCount, missingAssets, drawCalls, draws, counters, frameDebug, edge, cutoutEdge, minified, profile, capture, expect, twins, nineSlice, count, seam, resize, preview, meshPreview, grid, deviceLoss, roundtrip, meshResident, meshAsset, meshMaterial, meshPrefab, setField, animator, pick, cameraTarget }, server);+ // ESTELLA_VERIFY_SHADING: authored A, clay C, albedo L, authored again A2, through one eye.+ // Clay has no chroma but a spread of tones (it is lit); albedo keeps colour and is flatter;+ // A2 == A byte for byte, so leaving a mode leaves nothing behind.+ let shading = null;+ if (process.env.ESTELLA_VERIFY_SHADING) {+ const api = (call) => exec(`(async () => { const api = window.__estellaHeadless.api; ${call}; await api.step(2, 1 / 60); })()`);+ const stats = (name) => readFrame(`+ window.__shade = window.__shade || {};+ window.__shade[${JSON.stringify(name)}] = px.slice();+ const lum = (i) => 0.2126 * px[i] + 0.7152 * px[i + 1] + 0.0722 * px[i + 2];+ const tones = []; let chroma = 0;+ for (let i = 0; i < px.length; i += 4) {+ if (lum(i) <= 30) continue;+ tones.push(lum(i));+ chroma += Math.max(px[i], px[i + 1], px[i + 2]) - Math.min(px[i], px[i + 1], px[i + 2]);+ }+ tones.sort((a, b) => a - b);+ const n = tones.length;+ return { litShare: n / (px.length / 4), chroma: n ? chroma / n : 0, spread: n ? tones[Math.floor(n * 0.95)] - tones[Math.floor(n * 0.05)] : 0 };+ `);+ const diff = (a, b) => readFrame(`+ const A = window.__shade[${JSON.stringify(a)}], B = window.__shade[${JSON.stringify(b)}];+ let max = 0, differing = 0;+ for (let i = 0; i < A.length; i++) { const d = Math.abs(A[i] - B[i]); if (d > max) max = d; if (d > 0) differing++; }+ return { max, differing };+ `);+ await api(`api.setViewShading('shaded')`);+ const A = await stats('A');+ await api(`api.setViewShading('clay')`);+ const C = await stats('C');+ await api(`api.setViewShading('albedo')`);+ const L = await stats('L');+ const dClay = await diff('A', 'C');+ const dAlbedo = await diff('A', 'L');+ await api(`api.setViewShading('shaded')`);+ await stats('A2');+ const back = await diff('A', 'A2');+ shading = { A, C, L, dClay, dAlbedo, back,+ ok: A.chroma > 12 && C.chroma < 6 && C.litShare > 0.05 && C.spread > 20 && dClay.differing > 500+ && L.chroma > 12 && L.spread < A.spread && dAlbedo.differing > 200 && back.max === 0 };+ }+ finish({ ok: true, studio, shading, entityCount, missingAssets, drawCalls, draws, counters, frameDebug, edge, cutoutEdge, minified, profile, capture, expect, twins, nineSlice, count, seam, resize, preview, meshPreview, grid, deviceLoss, roundtrip, meshResident, meshAsset, meshMaterial, meshPrefab, setField, animator, pick, cameraTarget }, server);} catch (e) {finish({ ok: false, error: String((e && e.stack) || e) }, server);}diff --git a/tools/renderScenes.mjs b/tools/renderScenes.mjsindex 2ab8e1800..5a8b3921a 100644--- a/tools/renderScenes.mjs+++ b/tools/renderScenes.mjs@@ -89,6 +89,9 @@ export const SCENES = [{ id: "studio-preview-nolight", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/studio-preview-nolight.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_STUDIO": "{\"studio\":{},\"dark\":true,\"sky\":\"noop\"}"} },{ id: "studio-preview-sun", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/mesh-builtin.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_STUDIO": "{\"studio\":{},\"dark\":false}"} },{ id: "studio-preview-hdr", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/studio-preview-hdr.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_PERSPECTIVE": "1", "ESTELLA_VERIFY_ORBIT": "0,0", "ESTELLA_VERIFY_STUDIO": "{\"studio\":{},\"dark\":false,\"sky\":\"adds\"}"} },+ // The editor eye's clay and albedo modes: clay drops everyone's colours and keeps the light,+ // albedo keeps the colours and drops the light, and leaving either restores the authored frame.+ { id: "view-shading", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/view-shading.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_SHADING": "1"} },{ id: "studio-exposure", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/mesh-builtin.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_STUDIO": "{\"exposure\":-1}"} },{ id: "studio-exposure-linear", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_COLORSPACE": "linear", "ESTELLA_VERIFY_SCENE": "/scenes/mesh-builtin.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_STUDIO": "{\"exposure\":-1,\"linear\":true}"} },{ id: "frame-debugger-2d", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-rendering.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sprite-rendering.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_FRAME_DEBUG: "1" } },