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): the viewport colours a chosen joint's skin weights on the surface of its mesh
yhh0d6f70005fbe
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 01b1cd50d..f1f4c40a7 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. 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.+- **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. 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.- **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 32445478f..9162c013c 160000--- a/desktop+++ b/desktop@@ -1 +1 @@-Subproject commit 32445478fa44f984006f3664697cec85e024c75c+Subproject commit 9162c013c6249a3b8ea3b58efc13079e34cbb777diff --git a/sdk/etc/index.api.md b/sdk/etc/index.api.mdindex 014bbffa7..564dca413 100644--- a/sdk/etc/index.api.md+++ b/sdk/etc/index.api.md@@ -3494,6 +3494,7 @@ ResourceDef<EditorViewShadingData>## EditorViewShadingData — interface @experimental```mode: ViewShading+weights: { entity: number; joint: number; } | null```## EditorWorkPlane — interface @experimental@@ -7073,7 +7074,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; setViewShading(view: number, mode: ViewShading): void; setMeshEdgeBuffers(enabled: boolean): 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; setMeshEdgeBuffers(enabled: boolean): void; setViewSkinWeights(view: number, entity: number | null, joint?: number): 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 @experimentaldiff --git a/sdk/etc/index.native.api.md b/sdk/etc/index.native.api.mdindex 2cc24279c..439f5a47e 100644--- a/sdk/etc/index.native.api.md+++ b/sdk/etc/index.native.api.md@@ -3502,6 +3502,7 @@ ResourceDef<EditorViewShadingData>## EditorViewShadingData — interface @experimental```mode: ViewShading+weights: { entity: number; joint: number; } | null```## EditorWorkPlane — interface @experimental@@ -7286,7 +7287,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; setViewShading(view: number, mode: ViewShading): void; setMeshEdgeBuffers(enabled: boolean): 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; setMeshEdgeBuffers(enabled: boolean): void; setViewSkinWeights(view: number, entity: number | null, joint?: number): 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 @experimentaldiff --git a/sdk/etc/index.node.api.md b/sdk/etc/index.node.api.mdindex 2c4c977e4..b777dcd7f 100644--- a/sdk/etc/index.node.api.md+++ b/sdk/etc/index.node.api.md@@ -3489,6 +3489,7 @@ ResourceDef<EditorViewShadingData>## EditorViewShadingData — interface @experimental```mode: ViewShading+weights: { entity: number; joint: number; } | null```## EditorWorkPlane — interface @experimental@@ -7068,7 +7069,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; setViewShading(view: number, mode: ViewShading): void; setMeshEdgeBuffers(enabled: boolean): 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; setMeshEdgeBuffers(enabled: boolean): void; setViewSkinWeights(view: number, entity: number | null, joint?: number): 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 @experimentaldiff --git a/sdk/etc/minigame.api.md b/sdk/etc/minigame.api.mdindex 3cf63d349..d59c0ec88 100644--- a/sdk/etc/minigame.api.md+++ b/sdk/etc/minigame.api.md@@ -3489,6 +3489,7 @@ ResourceDef<EditorViewShadingData>## EditorViewShadingData — interface @experimental```mode: ViewShading+weights: { entity: number; joint: number; } | null```## EditorWorkPlane — interface @experimental@@ -7361,7 +7362,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; setViewShading(view: number, mode: ViewShading): void; setMeshEdgeBuffers(enabled: boolean): 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; setMeshEdgeBuffers(enabled: boolean): void; setViewSkinWeights(view: number, entity: number | null, joint?: number): 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 @experimentaldiff --git a/sdk/etc/wasm.api.md b/sdk/etc/wasm.api.mdindex 037e5ff4b..52d8e580d 100644--- a/sdk/etc/wasm.api.md+++ b/sdk/etc/wasm.api.md@@ -493,6 +493,7 @@ renderer_setTextureParams: (textureId: number, minFilter: number, magFilter: numrenderer_setViewId: ((view: number) => void) | undefinedrenderer_setViewLighting: ((mode: number, rotationDegrees: number, keyIntensity: number, fillIntensity: number, skyIntensity: number, showSky: boolean) => void) | undefinedrenderer_setViewShading: ((view: number, mode: number) => void) | undefined+renderer_setViewSkinWeights: ((view: number, entity: number, joint: 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 189b5625e..3e3e43a3e 100644--- a/sdk/etc/wechat.api.md+++ b/sdk/etc/wechat.api.md@@ -3489,6 +3489,7 @@ ResourceDef<EditorViewShadingData>## EditorViewShadingData — interface @experimental```mode: ViewShading+weights: { entity: number; joint: number; } | null```## EditorWorkPlane — interface @experimental@@ -7075,7 +7076,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; setViewShading(view: number, mode: ViewShading): void; setMeshEdgeBuffers(enabled: boolean): 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; setMeshEdgeBuffers(enabled: boolean): void; setViewSkinWeights(view: number, entity: number | null, joint?: number): 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 @experimentaldiff --git a/sdk/src/camera/CameraPlugin.ts b/sdk/src/camera/CameraPlugin.tsindex cd0e5c18d..c94e46fe1 100644--- a/sdk/src/camera/CameraPlugin.ts+++ b/sdk/src/camera/CameraPlugin.ts@@ -23,7 +23,7 @@ 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 { EditorViewShading, DEFAULT_EDITOR_VIEW_SHADING, pushEditorViewShading, pushEditorViewWeights } 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';@@ -791,6 +791,7 @@ export function cameraPlugin(// 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;+ let lastViewWeights = '';// 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.@@ -864,6 +865,10 @@ export function cameraPlugin(app.getResource(EditorViewShading),app.hasResource(EditorView) && app.getResource(EditorView).active,lastViewShading);+ lastViewWeights = pushEditorViewWeights(+ app.getResource(EditorViewShading),+ app.hasResource(EditorView) && app.getResource(EditorView).active,+ lastViewWeights);pipeline.beginFrame(elapsed);app.measureFrameScope('render.updateTransforms', () =>Renderer.updateTransforms({ _cpp: cppRegistry }));diff --git a/sdk/src/camera/EditorViewShading.ts b/sdk/src/camera/EditorViewShading.tsindex 27a8361ee..2f8071316 100644--- a/sdk/src/camera/EditorViewShading.ts+++ b/sdk/src/camera/EditorViewShading.ts@@ -16,9 +16,11 @@ import { EDITOR_VIEW_ENTITY } from './uiLayoutRect';export interface EditorViewShadingData {mode: ViewShading;+ /** The one skinned entity to colour by a joint's weights, and the joint (an index into its bind matrices). */+ weights: { entity: number; joint: number } | null;}-export const DEFAULT_EDITOR_VIEW_SHADING: EditorViewShadingData = { mode: 'shaded' };+export const DEFAULT_EDITOR_VIEW_SHADING: EditorViewShadingData = { mode: 'shaded', weights: null };export const EditorViewShading = defineResource<EditorViewShadingData>({ ...DEFAULT_EDITOR_VIEW_SHADING }, 'EditorViewShading');@@ -32,6 +34,19 @@ export function editorViewShadingMode(data: EditorViewShadingData, viewActive: b* 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 editorViewWeightsKey(data: EditorViewShadingData, viewActive: boolean): string {+ return viewActive && data.weights ? `${data.weights.entity}:${data.weights.joint}` : '';+}++/** Pushes the skin-weight target to the engine, once per change; returns the key it pushed. */+export function pushEditorViewWeights(data: EditorViewShadingData, viewActive: boolean, lastKey: string): string {+ const key = editorViewWeightsKey(data, viewActive);+ if (key === lastKey) return lastKey;+ const target = viewActive ? data.weights : null;+ Renderer.setViewSkinWeights(EDITOR_VIEW_ENTITY >>> 0, target ? target.entity : null, target?.joint ?? 0);+ return key;+}+export function pushEditorViewShading(data: EditorViewShadingData,viewActive: boolean,diff --git a/sdk/src/ecs/bridge/nativeBindings.ts b/sdk/src/ecs/bridge/nativeBindings.tsindex 46a646ae6..e01066ba0 100644--- a/sdk/src/ecs/bridge/nativeBindings.ts+++ b/sdk/src/ecs/bridge/nativeBindings.ts@@ -209,6 +209,8 @@ export const RENDERER_OPTIONAL_BINDINGS = {setViewShading: 'es_renderer_setViewShading',/** Edge buffers for meshes realized from now on — a wireframe view's geometry. */setMeshEdgeBuffers: 'es_renderer_setMeshEdgeBuffers',+ /** Colour one skinned entity by a joint's weights — an editor's view of a rig. */+ setViewSkinWeights: 'es_renderer_setViewSkinWeights',/** 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 0814fbc55..44d78d976 100644--- a/sdk/src/ecs/bridge/nativeEngineApi.generated.ts+++ b/sdk/src/ecs/bridge/nativeEngineApi.generated.ts@@ -202,6 +202,7 @@ export interface NativeEngineApi {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;@@ -504,6 +505,7 @@ export function createNativeEngineApi(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);diff --git a/sdk/src/ecs/bridge/nativeRenderer.ts b/sdk/src/ecs/bridge/nativeRenderer.tsindex 6dc136a08..559b5e6d4 100644--- a/sdk/src/ecs/bridge/nativeRenderer.ts+++ b/sdk/src/ecs/bridge/nativeRenderer.ts@@ -191,6 +191,10 @@ export function createNativeRendererBackend(const fn = scope[RENDERER_OPTIONAL_BINDINGS.setMeshEdgeBuffers];if (typeof fn === 'function') (fn as (e: boolean) => void)(enabled);},+ setViewSkinWeights: (view, entity, joint): void => {+ const fn = scope[RENDERER_OPTIONAL_BINDINGS.setViewSkinWeights];+ if (typeof fn === 'function') (fn as (v: number, e: number, j: number) => void)(view >>> 0, entity >>> 0, joint);+ },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 96dba60ee..014ed7d4a 100644--- a/sdk/src/render/renderer.ts+++ b/sdk/src/render/renderer.ts@@ -77,6 +77,7 @@ export interface RendererBackend {setLodPreview(view: number, entity: number, level: number | null): void;setViewShading(view: number, mode: number): void;setMeshEdgeBuffers(enabled: boolean): void;+ setViewSkinWeights(view: number, entity: number, joint: number): void;lightStatus(entity: number): LightStatus | null;shadowStatus(entity: number): ShadowStatus | null;getStats(): RenderStats;@@ -263,6 +264,7 @@ function wasmBackend(m: ESEngineModule): RendererBackend {m.renderer_setLodPreview?.(view >>> 0, entity >>> 0, level ?? -1),setViewShading: (view, mode) => m.renderer_setViewShading?.(view >>> 0, mode),setMeshEdgeBuffers: (enabled) => m.renderer_setMeshEdgeBuffers?.(enabled),+ setViewSkinWeights: (view, entity, joint) => m.renderer_setViewSkinWeights?.(view >>> 0, entity >>> 0, joint),shadowStatus: (entity) => {if (!m.renderer_shadowStatus || !lightStatusPtr) return null;if (!m.renderer_shadowStatus(entity >>> 0, lightStatusPtr)) return null;@@ -713,6 +715,18 @@ export const Renderer = {backend?.setMeshEdgeBuffers(enabled);},+ /**+ * Colour one skinned entity in `view` by how much a joint moves each of its vertices;+ * `null` stops. @experimental+ *+ * `joint` is an index into the mesh's own bind matrices, the order its joint channel+ * uses. View state like the shading beside it: the same entity drawn through another+ * view keeps its look.+ */+ setViewSkinWeights(view: number, entity: number | null, joint = 0): void {+ backend?.setViewSkinWeights(view, entity ?? 0, entity === null ? -1 : joint);+ },+/*** 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 b86d69ee6..6670f5daf 100644--- a/sdk/src/wasm.ts+++ b/sdk/src/wasm.ts@@ -674,6 +674,7 @@ export interface ESEngineModule {renderer_setLodPreview?(view: number, entity: number, level: number): void;renderer_setViewShading?(view: number, mode: number): void;renderer_setMeshEdgeBuffers?(enabled: boolean): void;+ renderer_setViewSkinWeights?(view: number, entity: number, joint: 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 0e28415e6..5aec494f8 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: () => {}, setViewShading: () => {}, setMeshEdgeBuffers: () => {}, lightStatus: () => null, shadowStatus: () => null,+ lodInspect: () => null, setLodPreview: () => {}, setViewShading: () => {}, setMeshEdgeBuffers: () => {}, setViewSkinWeights: () => {}, 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 e6cffec15..0cb3526c2 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: () => {}, setViewShading: () => {}, setMeshEdgeBuffers: () => {}, lightStatus: () => null, shadowStatus: () => null,+ lodInspect: () => null, setLodPreview: () => {}, setViewShading: () => {}, setMeshEdgeBuffers: () => {}, setViewSkinWeights: () => {}, 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.tsindex 35c050473..944a100b0 100644--- a/sdk/tests/editor-view-shading.test.ts+++ b/sdk/tests/editor-view-shading.test.ts@@ -7,28 +7,55 @@import { describe, it, expect, vi, beforeEach } from 'vitest';const calls = vi.hoisted(() => [] as [number, string][]);+const weightCalls = vi.hoisted(() => [] as [number, number | null, number][]);vi.mock('../src/render/renderer', () => ({- Renderer: { setViewShading: (view: number, mode: string) => { calls.push([view, mode]); } },+ Renderer: {+ setViewShading: (view: number, mode: string) => { calls.push([view, mode]); },+ setViewSkinWeights: (view: number, entity: number | null, joint: number) => { weightCalls.push([view, entity, joint]); },+ },}));-import { DEFAULT_EDITOR_VIEW_SHADING, editorViewShadingMode, pushEditorViewShading } from '../src/camera/EditorViewShading';+import { DEFAULT_EDITOR_VIEW_SHADING, editorViewShadingMode, pushEditorViewShading, pushEditorViewWeights } from '../src/camera/EditorViewShading';import { EDITOR_VIEW_ENTITY } from '../src/camera/uiLayoutRect';-beforeEach(() => { calls.length = 0; });+beforeEach(() => { calls.length = 0; weightCalls.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(editorViewShadingMode({ mode: 'clay', weights: null }, false)).toBe('shaded');+ expect(editorViewShadingMode({ mode: 'albedo', weights: null }, 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);+ let last = pushEditorViewShading({ mode: 'clay', weights: null }, true, null);+ last = pushEditorViewShading({ mode: 'clay', weights: null }, true, last);+ last = pushEditorViewShading({ mode: 'clay', weights: null }, false, last);+ last = pushEditorViewShading({ mode: 'clay', weights: null }, false, last);expect(last).toBe('shaded');expect(calls).toEqual([[EDITOR_VIEW_ENTITY >>> 0, 'clay'], [EDITOR_VIEW_ENTITY >>> 0, 'shaded']]);});});++describe('the skin-weight target', () => {+ const data = { mode: 'shaded' as const, weights: { entity: 41, joint: 3 } };++ it('names one entity and joint, once per change, in the editor view', () => {+ let key = pushEditorViewWeights(data, true, '');+ key = pushEditorViewWeights(data, true, key);+ key = pushEditorViewWeights({ ...data, weights: { entity: 41, joint: 4 } }, true, key);+ expect(weightCalls).toEqual([[EDITOR_VIEW_ENTITY >>> 0, 41, 3], [EDITOR_VIEW_ENTITY >>> 0, 41, 4]]);+ expect(key).toBe('41:4');+ });++ it('is cleared whenever the editor eye is not drawing, and when nothing is chosen', () => {+ let key = pushEditorViewWeights(data, true, '');+ key = pushEditorViewWeights(data, false, key);+ key = pushEditorViewWeights(data, false, key);+ expect(weightCalls.at(-1)).toEqual([EDITOR_VIEW_ENTITY >>> 0, null, 0]);+ expect(weightCalls).toHaveLength(2);+ key = pushEditorViewWeights({ mode: 'shaded', weights: null }, true, key);+ expect(key).toBe('');+ expect(weightCalls).toHaveLength(2);+ });+});diff --git a/src/esengine/bindings/RendererBindings.cpp b/src/esengine/bindings/RendererBindings.cppindex de669e4db..991e052de 100644--- a/src/esengine/bindings/RendererBindings.cpp+++ b/src/esengine/bindings/RendererBindings.cpp@@ -1102,6 +1102,12 @@ void renderer_setViewShading(u32 view, i32 mode) {g_renderFrame->setViewShading(view, known);}+void renderer_setViewSkinWeights(u32 view, u32 entity, i32 joint) {+ if (!g_renderFrame) return;+ g_renderFrame->setViewSkinWeights(view, joint < 0 ? INVALID_ENTITY : Entity::fromRaw(entity),+ joint < 0 ? 0u : static_cast<u32>(joint));+}+void renderer_setMeshEdgeBuffers(bool enabled) {if (auto* resources = ctx().tryGet<resource::ResourceManager>()) resources->setMeshEdgeBuffers(enabled);}diff --git a/src/esengine/bindings/RendererBindings.hpp b/src/esengine/bindings/RendererBindings.hppindex af28078b8..b58db17ad 100644--- a/src/esengine/bindings/RendererBindings.hpp+++ b/src/esengine/bindings/RendererBindings.hpp@@ -242,6 +242,13 @@ void renderer_setViewShading(u32 view, i32 mode);*/void renderer_setMeshEdgeBuffers(bool enabled);+/**+ * @brief Colour one skinned entity in a view by how much a joint moves each vertex.+ * @details @p joint indexes the mesh's own bind matrices, the order its Joints channel uses; a+ * negative joint goes back to no entity. A view that is not the editor's never asks.+ */+void renderer_setViewSkinWeights(u32 view, u32 entity, i32 joint);+/*** @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 5d7d83655..8eab45f47 100644--- a/src/esengine/bindings/WebSDKEntry.cpp+++ b/src/esengine/bindings/WebSDKEntry.cpp@@ -774,6 +774,7 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {emscripten::function("renderer_setLodPreview", &esengine::renderer_setLodPreview);emscripten::function("renderer_setViewShading", &esengine::renderer_setViewShading);emscripten::function("renderer_setMeshEdgeBuffers", &esengine::renderer_setMeshEdgeBuffers);+ emscripten::function("renderer_setViewSkinWeights", &esengine::renderer_setViewSkinWeights);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/data/shaders/mesh.esshader b/src/esengine/data/shaders/mesh.esshaderindex 535e03197..98492fee0 100644--- a/src/esengine/data/shaders/mesh.esshader+++ b/src/esengine/data/shaders/mesh.esshader@@ -39,6 +39,13 @@// land where its skinned self lands, and one copy of that is one that cannot drift.#pragma feature SHADOW_DEPTH+// A skinned surface coloured by how much ONE joint moves each vertex: the weight a rig is+// painted with, read off the surface instead of a table. The joint is the record's tint x+// (a diagnostic draw has no tint to carry), the colour goes out through the same varying the+// fragment already multiplies a white texture by — so the fragment stage is untouched, and+// the two twins differ only in the lines below that say it.+#pragma feature WEIGHT_HEAT+// GPU-resident geometry. Slot 0 is the mesh's own vertices, which are LOCAL// space and are never rewritten; slot 1 is the per-object record the frame// streams, so the same mesh drawn twice costs one more transform rather than@@ -154,6 +161,15 @@ void main() {gl_Position = u_projection * world;v_texCoord = a_texCoord;v_color = a_color * esInstanceTint();+#if defined(WEIGHT_HEAT) && defined(SKINNED)+ {+ uint chosen = uint(esInstanceTint().x);+ vec4 own = vec4(equal(a_joints, uvec4(chosen)));+ float heat = dot(own, a_weights);+ // Nothing the joint moves stays a quiet grey, so the part that matters is the part that shows.+ v_color = vec4(heat < 0.01 ? vec3(0.1) : mix(vec3(0.2, 0.4, 1.0), vec3(1.0, 0.25, 0.2), clamp(heat, 0.0, 1.0)), 1.0);+ }+#endif#ifdef MESH_LIGHTMAPhighp vec4 lmRect = esInstanceLightmapRect();v_lightmap = vec3(a_texCoord1 * lmRect.xy + lmRect.zw,@@ -329,6 +345,17 @@ struct VSOut {out.pos = frame.projection * world;out.v_texCoord = v.a_texCoord;out.v_color = v.a_color * esInstanceTint();+#ifdef WEIGHT_HEAT+#ifdef SKINNED+ {+ let chosen = u32(esInstanceTint().x);+ let own = vec4f(v.a_joints == vec4u(chosen));+ let heat = dot(own, v.a_weights);+ out.v_color = vec4f(select(mix(vec3f(0.2, 0.4, 1.0), vec3f(1.0, 0.25, 0.2), clamp(heat, 0.0, 1.0)),+ vec3f(0.1), heat < 0.01), 1.0);+ }+#endif+#endif#ifdef MESH_LIGHTMAPlet lmRect = esInstanceLightmapRect();out.v_lightmap = vec3f(v.a_texCoord1 * lmRect.xy + lmRect.zw,diff --git a/src/esengine/renderer/RenderTypePlugin.hpp b/src/esengine/renderer/RenderTypePlugin.hppindex c3ce35be7..e90d34cc8 100644--- a/src/esengine/renderer/RenderTypePlugin.hpp+++ b/src/esengine/renderer/RenderTypePlugin.hpp@@ -328,6 +328,9 @@ struct RenderCollectContext {* it alone, because a depth write has no colour to override.*/ShadingMode shading = ShadingMode::Shaded;++ /** @brief The one skinned draw this view colours by a joint's weights, if any. */+ WeightTarget weights;};/** @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 8764cc786..7c4b81d27 100644--- a/src/esengine/renderer/frame/RenderFrame.cpp+++ b/src/esengine/renderer/frame/RenderFrame.cpp@@ -2138,6 +2138,7 @@ void RenderFrame::collectAll(ecs::Registry& registry) {collectCtx.screen_ui = screen_domain_;collectCtx.lod = {view_id_, &lod_view_state_, &lod_counts_};collectCtx.shading = view_shading_.get(view_id_);+ collectCtx.weights = view_shading_.weights(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 19979dfb7..c0f2927f3 100644--- a/src/esengine/renderer/frame/RenderFrame.hpp+++ b/src/esengine/renderer/frame/RenderFrame.hpp@@ -327,6 +327,12 @@ public:*/void setViewShading(u32 view, ShadingMode mode) { view_shading_.set(view, mode); }+ /**+ * @brief Colour @p entity in @p view by how much @p joint moves each of its vertices.+ * @details View state like the shading beside it; an invalid entity goes back to none.+ */+ void setViewSkinWeights(u32 view, Entity entity, u32 joint) { view_shading_.setWeights(view, entity, joint); }+/** @brief The mode @p view asked for; Shaded when it never did. */ShadingMode viewShading(u32 view) const { return view_shading_.get(view); }diff --git a/src/esengine/renderer/frame/ViewShading.hpp b/src/esengine/renderer/frame/ViewShading.hppindex ac8c3d0ec..c19a20622 100644--- a/src/esengine/renderer/frame/ViewShading.hpp+++ b/src/esengine/renderer/frame/ViewShading.hpp@@ -32,6 +32,17 @@ enum class ShadingMode : u8 {inline constexpr u8 kShadingModeCount = 4;+/**+ * @brief The one skinned entity a view colours by a joint's weights, and which joint.+ * @details Not a ShadingMode: it picks out ONE draw among many, and everything else keeps the+ * view's shading. A view with none stands for "the weights of nothing".+ */+struct WeightTarget {+ Entity entity = INVALID_ENTITY;+ u32 joint = 0;+ bool active() const { return entity != INVALID_ENTITY; }+};+/*** @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.@@ -49,10 +60,22 @@ public:}/// Views holding a non-default mode, for a criterion that checks nothing leaked.- usize count() const { return modes_.size(); }+ usize count() const { return modes_.size() + weights_.size(); }++ /// Colour @p entity in @p view by how much @p joint moves each vertex; an invalid entity stops.+ void setWeights(u32 view, Entity entity, u32 joint) {+ if (entity == INVALID_ENTITY) weights_.erase(view);+ else weights_[view] = {entity, joint};+ }++ WeightTarget weights(u32 view) const {+ const auto it = weights_.find(view);+ return it == weights_.end() ? WeightTarget{} : it->second;+ }private:std::unordered_map<u32, ShadingMode> modes_;+ std::unordered_map<u32, WeightTarget> weights_;};} // namespace esenginediff --git a/src/esengine/renderer/plugins/MeshPlugin.cpp b/src/esengine/renderer/plugins/MeshPlugin.cppindex f154aa892..a1542e0b6 100644--- a/src/esengine/renderer/plugins/MeshPlugin.cpp+++ b/src/esengine/renderer/plugins/MeshPlugin.cpp@@ -247,10 +247,10 @@ void reportLodAuthoring(const LodLevels& levels, bool& warned) {}u32 meshVariant(bool normals, bool lit, bool normalMapped, bool skinned, bool depthOnly,- bool envMapped, bool lightmapped) {+ bool envMapped, bool lightmapped, bool weightHeat = false) {return (normals ? 1u : 0u) | (lit ? 2u : 0u) | (normalMapped ? 4u : 0u)| (skinned ? 8u : 0u) | (depthOnly ? 16u : 0u) | (envMapped ? 32u : 0u)- | (lightmapped ? 64u : 0u);+ | (lightmapped ? 64u : 0u) | (weightHeat ? 128u : 0u);}/**@@ -299,13 +299,16 @@ struct MeshDrawKeys {u32 normalTextureId = 0;};-u32 meshVariantFrom(const MeshProgramFacts& facts, bool envMapped, bool shadowDepth) {+u32 meshVariantFrom(const MeshProgramFacts& facts, bool envMapped, bool shadowDepth, bool weightHeat = false) {// `lightmapped` survives the shadow pass, unlike the three describing// shading: it declares two vertex attributes, and a layout may not carry one// the program ignores. The depth fragment simply never reads the atlas.- return meshVariant(facts.hasNormals, facts.lit && !shadowDepth,- facts.normalTextureId != 0 && !shadowDepth, facts.skinned, shadowDepth,- envMapped, facts.lightmapped);+ // Weights are read off the surface of a skinned draw and nothing else's: the colour is+ // the shade, so it asks for no light, no normal map and no depth pass of its own.+ const bool heat = weightHeat && facts.skinned && !shadowDepth;+ return meshVariant(facts.hasNormals, facts.lit && !shadowDepth && !heat,+ facts.normalTextureId != 0 && !shadowDepth && !heat, facts.skinned, shadowDepth,+ envMapped, facts.lightmapped, heat);}/** @brief The facts a LIVE entity answers with: its components and its mesh. */@@ -329,10 +332,10 @@ MeshProgramFacts meshFactsFromEntity(RenderFrameContext& ctx, ecs::Registry& regMeshDrawKeys meshDrawFor(RenderFrameContext& ctx, ecs::Registry& registry, Entity entity,const ecs::MeshRenderer& mesh, const Mesh* resident, bool shadowDepth,- bool& warnedBones) {+ bool& warnedBones, bool weightHeat = false) {const MeshProgramFacts facts =meshFactsFromEntity(ctx, registry, entity, mesh, resident, warnedBones);- return { meshVariantFrom(facts, ctx.environment_texture_id != 0, shadowDepth),+ return { meshVariantFrom(facts, ctx.environment_texture_id != 0, shadowDepth, weightHeat),facts.normalTextureId };}} // namespace@@ -369,7 +372,7 @@ u32 MeshPlugin::meshProgram(RenderFrameContext& ctx, u32 variant) {const bool normals = (variant & 1u) != 0, lit = (variant & 2u) != 0;const bool normalMapped = (variant & 4u) != 0, skinned = (variant & 8u) != 0;const bool depthOnly = (variant & 16u) != 0, envMapped = (variant & 32u) != 0;- const bool lightmapped = (variant & 64u) != 0;+ const bool lightmapped = (variant & 64u) != 0, weightHeat = (variant & 128u) != 0;if (mesh_compiled_[variant]) return mesh_programs_[variant];mesh_compiled_[variant] = true;// Counted because the cost of this function is entirely the times it does@@ -385,6 +388,7 @@ u32 MeshPlugin::meshProgram(RenderFrameContext& ctx, u32 variant) {if (normalMapped) features.emplace_back("NORMAL_MAP");if (skinned) features.emplace_back("SKINNED");if (lightmapped) features.emplace_back("MESH_LIGHTMAP");+ if (weightHeat) features.emplace_back("WEIGHT_HEAT");if (depthOnly) features.emplace_back("SHADOW_DEPTH");// Resident geometry owns its texture slots, so it is the vertex source that can// carry a shadow map and a reflection — the batch stream's are a per-vertex@@ -530,7 +534,14 @@ void MeshPlugin::collect(RenderCollectContext& collect_ctx) {++walked;const auto& authored = meshView.get<ecs::MeshRenderer>(entity);const ecs::MeshRenderer* described = &authored;- if (shading != ShadingMode::Shaded) {+ const bool heated = !shadowDepth && collect_ctx.weights.entity == entity;+ if (heated) {+ shaded = authored;+ applyShading(shaded, ShadingMode::Albedo);+ shaded.texture = {};+ shaded.color = glm::vec4(static_cast<f32>(collect_ctx.weights.joint), 0.0f, 0.0f, 1.0f);+ described = &shaded;+ } else if (shading != ShadingMode::Shaded) {shaded = authored;applyShading(shaded, shading);described = &shaded;@@ -633,7 +644,7 @@ void MeshPlugin::collect(RenderCollectContext& collect_ctx) {}}const MeshDrawKeys keys =- meshDrawFor(ctx, registry, entity, mesh, resident, shadowDepth, warned_bones_);+ meshDrawFor(ctx, registry, entity, mesh, resident, shadowDepth, warned_bones_, heated);const u32 normalTextureId = keys.normalTextureId;BatchDrawKey key{diff --git a/src/esengine/renderer/rhi/GfxEnums.hpp b/src/esengine/renderer/rhi/GfxEnums.hppindex 223ad1bb0..488aea2b0 100644--- a/src/esengine/renderer/rhi/GfxEnums.hpp+++ b/src/esengine/renderer/rhi/GfxEnums.hpp@@ -139,7 +139,7 @@ static constexpr u32 MORPH_MAX_TEXELS = MORPH_TEXTURE_WIDTH * MORPH_TEXTURE_WIDT/// Programs the resident-mesh shader has: one per combination of {normals, lit,/// normal-mapped, skinned, depth-only, env-mapped, lightmapped}. Seven bits, not/// one: the geometry, the draw, the frame and the pass each answer a different.-static constexpr u32 MESH_VARIANTS = 128;+static constexpr u32 MESH_VARIANTS = 256;/*** @brief What a mesh vertex channel MEANS, and the attribute location it binds to.* @details One vocabulary for the file format, the layout and the shaders: adiff --git a/src/esengine/renderer/rhi/ShaderEmbeds.generated.hpp b/src/esengine/renderer/rhi/ShaderEmbeds.generated.hppindex b381bd9d9..7efb4de01 100644--- a/src/esengine/renderer/rhi/ShaderEmbeds.generated.hpp+++ b/src/esengine/renderer/rhi/ShaderEmbeds.generated.hpp@@ -408,6 +408,13 @@ inline constexpr const char* MESH = R"esshader(#pragma shader "Mesh"+#pragma feature WEIGHT_HEAT++++++#pragma vertexlayout(location = 0) in vec3 a_position;layout(location = 1) in vec4 a_color;@@ -518,6 +525,15 @@ void main() {gl_Position = u_projection * world;v_texCoord = a_texCoord;v_color = a_color * esInstanceTint();+#if defined(WEIGHT_HEAT) && defined(SKINNED)+ {+ uint chosen = uint(esInstanceTint().x);+ vec4 own = vec4(equal(a_joints, uvec4(chosen)));+ float heat = dot(own, a_weights);++ v_color = vec4(heat < 0.01 ? vec3(0.1) : mix(vec3(0.2, 0.4, 1.0), vec3(1.0, 0.25, 0.2), clamp(heat, 0.0, 1.0)), 1.0);+ }+#endif#ifdef MESH_LIGHTMAPhighp vec4 lmRect = esInstanceLightmapRect();v_lightmap = vec3(a_texCoord1 * lmRect.xy + lmRect.zw,@@ -693,6 +709,17 @@ struct VSOut {out.pos = frame.projection * world;out.v_texCoord = v.a_texCoord;out.v_color = v.a_color * esInstanceTint();+#ifdef WEIGHT_HEAT+#ifdef SKINNED+ {+ let chosen = u32(esInstanceTint().x);+ let own = vec4f(v.a_joints == vec4u(chosen));+ let heat = dot(own, v.a_weights);+ out.v_color = vec4f(select(mix(vec3f(0.2, 0.4, 1.0), vec3f(1.0, 0.25, 0.2), clamp(heat, 0.0, 1.0)),+ vec3f(0.1), heat < 0.01), 1.0);+ }+#endif+#endif#ifdef MESH_LIGHTMAPlet lmRect = esInstanceLightmapRect();out.v_lightmap = vec3f(v.a_texCoord1 * lmRect.xy + lmRect.zw,diff --git a/tools/check-render-scenes.mjs b/tools/check-render-scenes.mjsindex 27b305f2c..ab9f07e34 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_SHADING || s.env.ESTELLA_VERIFY_PREVIEW+ || s.env.ESTELLA_VERIFY_GRID || s.env.ESTELLA_VERIFY_STUDIO || s.env.ESTELLA_VERIFY_SHADING || s.env.ESTELLA_VERIFY_SKIN_WEIGHTS || 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 42c837aa9..855cb00b1 100644--- a/tools/releaseNotes.mjs+++ b/tools/releaseNotes.mjs@@ -116,6 +116,8 @@ export const NOTED = {{ note: 'Gizmos are redrawn.' },'feat(render): a view can draw meshes as a wireframe, with hidden edges hidden, through a line topology in the pipeline and an edge buffer on each mesh':{ note: 'Gizmos are redrawn.' },+ "feat(render): the viewport colours a chosen joint's skin weights on the surface of its mesh":+ { 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 2767f0761..67386e773 100644--- a/tools/render-host/host.ts+++ b/tools/render-host/host.ts@@ -695,6 +695,14 @@ const api = {app.getResource(EditorViewShading).mode = mode;},+ /** Colour one skinned scene entity by how much a joint moves its vertices (null stops). */+ setSkinWeights(id: number | null, joint = 0): void {+ if (!app) throw new Error('set_skin_weights before boot');+ const view = app.getResource(EditorView);+ if (!view.active) { seedEditorViewFromScene(); view.active = true; }+ app.getResource(EditorViewShading).weights = id === null ? null : { entity: requireEntity(id) as number, joint };+ },+/** 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 4d6bd04f7..b7ff3dd08 100644--- a/tools/render-host/run.mjs+++ b/tools/render-host/run.mjs@@ -32,6 +32,7 @@* 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_SKIN_WEIGHTS colour a skinned entity by joint weights (JSON {id, joints}; 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)@@ -221,14 +222,15 @@ function finish(result, server) {// 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 shadingDrew = result.shading?.ok === true && (result.shading.C?.litShare ?? 0) > 0;- const renderedOk = (result.capture?.rendered ?? false) || uniformByDesign || studioDrew || shadingDrew;+ const weightsDrew = result.skinWeights?.ok === true;+ const renderedOk = (result.capture?.rendered ?? false) || uniformByDesign || studioDrew || shadingDrew || weightsDrew;// 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.shading?.ok ?? true) &&+ (result.meshPreview?.ok ?? true) && (result.grid?.ok ?? true) && (result.studio?.ok ?? true) && (result.shading?.ok ?? true) && (result.skinWeights?.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(', ')}`;@@ -1178,7 +1180,41 @@ app.whenReady().then(async () => {&& L.chroma > 12 && L.spread < A.spread && dAlbedo.differing > 200&& W.chroma < 6 && W.litShare > 0.003 && W.litShare < 0.2 && dWire.differing > 500 && 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);+ // ESTELLA_VERIFY_SKIN_WEIGHTS = {id, joints:[a, b]}: authored A, the entity coloured by joint a,+ // by joint b, authored again. Each joint moves a different part, so the two heat frames differ+ // from each other and from A, each carries the hot end of the ramp, and A2 == A byte for byte.+ let skinWeights = null;+ if (process.env.ESTELLA_VERIFY_SKIN_WEIGHTS) {+ const spec = JSON.parse(process.env.ESTELLA_VERIFY_SKIN_WEIGHTS);+ const api = (call) => exec(`(async () => { const api = window.__estellaHeadless.api; ${call}; await api.step(2, 1 / 60); })()`);+ const grab = (name) => readFrame(`+ window.__heat = window.__heat || {};+ window.__heat[${JSON.stringify(name)}] = px.slice();+ let hot = 0;+ for (let i = 0; i < px.length; i += 4) if (px[i] > 200 && px[i + 1] < 110 && px[i + 2] < 110) hot++;+ return { hot };+ `);+ const diff = (a, b) => readFrame(`+ const A = window.__heat[${JSON.stringify(a)}], B = window.__heat[${JSON.stringify(b)}];+ let differing = 0, max = 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.setSkinWeights(null)');+ await grab('A');+ await api(`api.setSkinWeights(${spec.id}, ${spec.joints[0]})`);+ const H0 = await grab('H0');+ await api(`api.setSkinWeights(${spec.id}, ${spec.joints[1]})`);+ const H1 = await grab('H1');+ const dA = await diff('A', 'H0');+ const dJoints = await diff('H0', 'H1');+ await api('api.setSkinWeights(null)');+ await grab('A2');+ const back = await diff('A', 'A2');+ skinWeights = { H0, H1, dA, dJoints, back,+ ok: H0.hot > 20 && H1.hot > 20 && dA.differing > 300 && dJoints.differing > 300 && back.max === 0 };+ }+ finish({ ok: true, studio, shading, skinWeights, 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 5a8b3921a..2bc0bcf9d 100644--- a/tools/renderScenes.mjs+++ b/tools/renderScenes.mjs@@ -92,6 +92,9 @@ export const SCENES = [// 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"} },+ // A skinned surface coloured by one joint's weights: each of the two joints of the rig colours its own+ // half, the hot end of the ramp is on screen, and leaving the view returns the authored frame.+ { id: "view-skin-weights", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/mesh-skin.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_SKIN_WEIGHTS": "{\"id\":3,\"joints\":[0,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" } },