Skip to content

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

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

yhh93b26d1cadc8
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 07c2b9def..f725da776 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_activity
test_shader_device test_draw_params test_per_draw_blocks test_texture_fb test_buffer_device
test_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_view_shading 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_mesh_edges test_hdr_format test_probe_store test_occlusion_view test_reflection_store
test_text_edit test_render_graph test_device_loss test_physics_interpolation
test_bitmap_font test_texture_cache test_material_shader_lifetime test_mesh_recovery test_aot_host test_aot_conformance
test_touch_stream
diff --git a/CHANGELOG.md b/CHANGELOG.md
index eca0223ed..01b1cd50d 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.
+- **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.
- **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/desktop
index 29201339c..32445478f 160000
--- a/desktop
+++ b/desktop
@@ -1 +1 @@
-Subproject commit 29201339c8812c32a9c71cc3a323d7ec6128485a
+Subproject commit 32445478fa44f984006f3664697cec85e024c75c
diff --git a/sdk/etc/index.api.md b/sdk/etc/index.api.md
index 1092b0b9c..014bbffa7 100644
--- a/sdk/etc/index.api.md
+++ b/sdk/etc/index.api.md
@@ -7073,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; 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; }
+{ 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; }
```
## ReplayReport — interface @experimental
@@ -10073,7 +10073,7 @@ volume: number | undefined
## ViewShading — type @experimental
```
-'shaded' | 'clay' | 'albedo'
+'shaded' | 'clay' | 'albedo' | 'wireframe'
```
## Viewport — interface @experimental
diff --git a/sdk/etc/index.native.api.md b/sdk/etc/index.native.api.md
index e79ef75a3..2cc24279c 100644
--- a/sdk/etc/index.native.api.md
+++ b/sdk/etc/index.native.api.md
@@ -7286,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; 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; }
+{ 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; }
```
## ReplayReport — interface @experimental
@@ -10286,7 +10286,7 @@ volume: number | undefined
## ViewShading — type @experimental
```
-'shaded' | 'clay' | 'albedo'
+'shaded' | 'clay' | 'albedo' | 'wireframe'
```
## Viewport — interface @experimental
diff --git a/sdk/etc/index.node.api.md b/sdk/etc/index.node.api.md
index 02788b420..2c4c977e4 100644
--- a/sdk/etc/index.node.api.md
+++ b/sdk/etc/index.node.api.md
@@ -7068,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; 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; }
+{ 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; }
```
## ReplayReport — interface @experimental
@@ -10068,7 +10068,7 @@ volume: number | undefined
## ViewShading — type @experimental
```
-'shaded' | 'clay' | 'albedo'
+'shaded' | 'clay' | 'albedo' | 'wireframe'
```
## Viewport — interface @experimental
diff --git a/sdk/etc/minigame.api.md b/sdk/etc/minigame.api.md
index db1d9eb0e..3cf63d349 100644
--- a/sdk/etc/minigame.api.md
+++ b/sdk/etc/minigame.api.md
@@ -7361,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; 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; }
+{ 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; }
```
## ReplayReport — interface @experimental
@@ -10367,7 +10367,7 @@ volume: number | undefined
## ViewShading — type @experimental
```
-'shaded' | 'clay' | 'albedo'
+'shaded' | 'clay' | 'albedo' | 'wireframe'
```
## Viewport — interface @experimental
diff --git a/sdk/etc/wasm.api.md b/sdk/etc/wasm.api.md
index 94f3c10cf..037e5ff4b 100644
--- a/sdk/etc/wasm.api.md
+++ b/sdk/etc/wasm.api.md
@@ -485,6 +485,7 @@ renderer_setCullingMask: ((mask: number) => void) | undefined
renderer_setDepthLayers: ((mask: number) => void) | undefined
renderer_setEntityDrawOrder: ((registry: CppRegistry, entitiesPtr: number, count: number) => void) | undefined
renderer_setLodPreview: ((view: number, entity: number, level: number) => void) | undefined
+renderer_setMeshEdgeBuffers: ((enabled: boolean) => void) | undefined
renderer_setQualityBudgets: ((atlasSize: number, cellSize: number, cascades: number, particleLimit: number) => void) | undefined
renderer_setShadowDistance: ((distance: number) => void) | undefined
renderer_setStage: (stage: number) => void
diff --git a/sdk/etc/wechat.api.md b/sdk/etc/wechat.api.md
index 7aaad9d2d..189b5625e 100644
--- a/sdk/etc/wechat.api.md
+++ b/sdk/etc/wechat.api.md
@@ -7075,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; 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; }
+{ 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; }
```
## ReplayReport — interface @experimental
@@ -10075,7 +10075,7 @@ volume: number | undefined
## ViewShading — type @experimental
```
-'shaded' | 'clay' | 'albedo'
+'shaded' | 'clay' | 'albedo' | 'wireframe'
```
## Viewport — interface @experimental
diff --git a/sdk/src/ecs/bridge/nativeBindings.ts b/sdk/src/ecs/bridge/nativeBindings.ts
index 9801d9a1d..46a646ae6 100644
--- a/sdk/src/ecs/bridge/nativeBindings.ts
+++ b/sdk/src/ecs/bridge/nativeBindings.ts
@@ -207,6 +207,8 @@ export const RENDERER_OPTIONAL_BINDINGS = {
setLodPreview: 'es_renderer_setLodPreview',
/** How a view shades its meshes — clay, albedo or as authored. An editor's view mode. */
setViewShading: 'es_renderer_setViewShading',
+ /** Edge buffers for meshes realized from now on — a wireframe view's geometry. */
+ setMeshEdgeBuffers: 'es_renderer_setMeshEdgeBuffers',
/** 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.ts
index b0a16fdae..0814fbc55 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_setMeshEdgeBuffers?(enabled: boolean): 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;
@@ -501,6 +502,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_setMeshEdgeBuffers', 'es_renderer_setMeshEdgeBuffers', false);
bind('renderer_setViewShading', 'es_renderer_setViewShading', false);
bind('renderer_setStage', 'es_renderer_setStage', false);
bind('renderer_setTextureParams', 'es_renderer_setTextureParams', false);
diff --git a/sdk/src/ecs/bridge/nativeRenderer.ts b/sdk/src/ecs/bridge/nativeRenderer.ts
index 2014abae3..6dc136a08 100644
--- a/sdk/src/ecs/bridge/nativeRenderer.ts
+++ b/sdk/src/ecs/bridge/nativeRenderer.ts
@@ -187,6 +187,10 @@ export function createNativeRendererBackend(
const fn = scope[RENDERER_OPTIONAL_BINDINGS.setViewShading];
if (typeof fn === 'function') (fn as (v: number, m: number) => void)(view >>> 0, mode);
},
+ setMeshEdgeBuffers: (enabled): void => {
+ const fn = scope[RENDERER_OPTIONAL_BINDINGS.setMeshEdgeBuffers];
+ if (typeof fn === 'function') (fn as (e: boolean) => void)(enabled);
+ },
getStats: (): RenderStats => {
const read = (name: string): number => {
const fn = scope[name];
diff --git a/sdk/src/render/renderer.ts b/sdk/src/render/renderer.ts
index 24f82509d..96dba60ee 100644
--- a/sdk/src/render/renderer.ts
+++ b/sdk/src/render/renderer.ts
@@ -76,6 +76,7 @@ export interface RendererBackend {
lodInspect(view: number, entity: number): LodDecision | null;
setLodPreview(view: number, entity: number, level: number | null): void;
setViewShading(view: number, mode: number): void;
+ setMeshEdgeBuffers(enabled: boolean): void;
lightStatus(entity: number): LightStatus | null;
shadowStatus(entity: number): ShadowStatus | null;
getStats(): RenderStats;
@@ -137,9 +138,9 @@ export interface LightStatus {
* 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';
+export type ViewShading = 'shaded' | 'clay' | 'albedo' | 'wireframe';
-const VIEW_SHADING_CODE: Record<ViewShading, number> = { shaded: 0, clay: 1, albedo: 2 };
+const VIEW_SHADING_CODE: Record<ViewShading, number> = { shaded: 0, clay: 1, albedo: 2, wireframe: 3 };
export interface LodDecision {
/** The level drawn, or `null` when the object was small enough to be culled. */
@@ -261,6 +262,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),
+ setMeshEdgeBuffers: (enabled) => m.renderer_setMeshEdgeBuffers?.(enabled),
shadowStatus: (entity) => {
if (!m.renderer_shadowStatus || !lightStatusPtr) return null;
if (!m.renderer_shadowStatus(entity >>> 0, lightStatusPtr)) return null;
@@ -694,13 +696,23 @@ export const Renderer = {
* 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.
+ * colour with no light, wireframe a dark surface with its edges; 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]);
},
+ /**
+ * Give meshes loaded from now on an edge buffer, which a wireframe view draws. @experimental
+ *
+ * A second index buffer per mesh, so off unless an editor asks, and asked before the
+ * assets load: a mesh realized earlier has none and is drawn as a plain surface.
+ */
+ setMeshEdgeBuffers(enabled: boolean): void {
+ backend?.setMeshEdgeBuffers(enabled);
+ },
+
/**
* What the light cap did to `entity` last frame, or null before any frame has
* collected lights. @experimental
diff --git a/sdk/src/wasm.ts b/sdk/src/wasm.ts
index 852f72719..b86d69ee6 100644
--- a/sdk/src/wasm.ts
+++ b/sdk/src/wasm.ts
@@ -673,6 +673,7 @@ export interface ESEngineModule {
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_setMeshEdgeBuffers?(enabled: boolean): 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.ts
index 1f514cd0b..0e28415e6 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: () => {}, lightStatus: () => null, shadowStatus: () => null,
+ lodInspect: () => null, setLodPreview: () => {}, setViewShading: () => {}, setMeshEdgeBuffers: () => {}, 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.ts
index 435d91424..e6cffec15 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: () => {}, lightStatus: () => null, shadowStatus: () => null,
+ lodInspect: () => null, setLodPreview: () => {}, setViewShading: () => {}, setMeshEdgeBuffers: () => {}, lightStatus: () => null, shadowStatus: () => null,
getStats: () => ({ drawCalls: 0, triangles: 0, sprites: 0, text: 0, skeletal: 0, meshes: 0, culled: 0 }),
};
}
diff --git a/src/esengine/bindings/RendererBindings.cpp b/src/esengine/bindings/RendererBindings.cpp
index b893159f1..de669e4db 100644
--- a/src/esengine/bindings/RendererBindings.cpp
+++ b/src/esengine/bindings/RendererBindings.cpp
@@ -1102,6 +1102,10 @@ void renderer_setViewShading(u32 view, i32 mode) {
g_renderFrame->setViewShading(view, known);
}
+void renderer_setMeshEdgeBuffers(bool enabled) {
+ if (auto* resources = ctx().tryGet<resource::ResourceManager>()) resources->setMeshEdgeBuffers(enabled);
+}
+
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.hpp
index 69d5920dd..af28078b8 100644
--- a/src/esengine/bindings/RendererBindings.hpp
+++ b/src/esengine/bindings/RendererBindings.hpp
@@ -235,6 +235,13 @@ void renderer_setLodPreview(u32 view, u32 entity, i32 level);
*/
void renderer_setViewShading(u32 view, i32 mode);
+/**
+ * @brief Give meshes realized from now on an edge buffer, for a wireframe view.
+ * @details A second index buffer per mesh, so off unless an editor asks, and asked BEFORE
+ * the assets load: a mesh realized earlier has none and is drawn filled instead.
+ */
+void renderer_setMeshEdgeBuffers(bool enabled);
+
/**
* @brief What the light cap did to @p entity last frame, into nine floats at
* @p outPtr: accepted, refusal, limit, requested, refusedCount, then whether
diff --git a/src/esengine/bindings/WebSDKEntry.cpp b/src/esengine/bindings/WebSDKEntry.cpp
index 90d6f3ba9..5d7d83655 100644
--- a/src/esengine/bindings/WebSDKEntry.cpp
+++ b/src/esengine/bindings/WebSDKEntry.cpp
@@ -773,6 +773,7 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {
emscripten::function("renderer_lodInspect", &esengine::renderer_lodInspect);
emscripten::function("renderer_setLodPreview", &esengine::renderer_setLodPreview);
emscripten::function("renderer_setViewShading", &esengine::renderer_setViewShading);
+ emscripten::function("renderer_setMeshEdgeBuffers", &esengine::renderer_setMeshEdgeBuffers);
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/draw/BatchBuilder.cpp b/src/esengine/renderer/draw/BatchBuilder.cpp
index c91f93a4a..3bed3cfb0 100644
--- a/src/esengine/renderer/draw/BatchBuilder.cpp
+++ b/src/esengine/renderer/draw/BatchBuilder.cpp
@@ -127,6 +127,7 @@ void pushBatchDraw(DrawList& drawList, const ClipState& clips,
cmd.depth_write = depthWrite;
cmd.cull = key.cull;
cmd.depth_bias = key.depthBias;
+ cmd.topology = key.topology;
// The Batch stream always samples a texture (white fallback at minimum); other
// streams bind one only when the draw actually has one (the shape stream is
// textureless, so execute() must not touch sampler units for it).
diff --git a/src/esengine/renderer/draw/BatchBuilder.hpp b/src/esengine/renderer/draw/BatchBuilder.hpp
index 16dcbcbcf..baf832889 100644
--- a/src/esengine/renderer/draw/BatchBuilder.hpp
+++ b/src/esengine/renderer/draw/BatchBuilder.hpp
@@ -116,6 +116,7 @@ struct BatchDrawKey {
bool depthWrite = true;
u8 cull = 0; ///< CullMode: 0 = none, 1 = back, 2 = front.
i16 depthBias = 0; ///< Depth-buffer units toward the eye. @see PipelineDesc.
+ GfxTopology topology = GfxTopology::Triangles; ///< How the indices assemble. @see PipelineDesc.
// The transient stream this draw's geometry lives in. Only the Batch stream carries
// a per-vertex texIndex, so only it participates in the multi-texture merge.
LayoutId layoutId = LayoutId::Batch;
diff --git a/src/esengine/renderer/draw/DrawCommand.hpp b/src/esengine/renderer/draw/DrawCommand.hpp
index 871825c4c..536ec06d4 100644
--- a/src/esengine/renderer/draw/DrawCommand.hpp
+++ b/src/esengine/renderer/draw/DrawCommand.hpp
@@ -115,6 +115,7 @@ struct DrawCommand {
bool depth_write = true;
u8 cull = 0; ///< CullMode: 0 = none, 1 = back, 2 = front.
i16 depth_bias = 0; ///< Depth-buffer units toward the eye. @see PipelineDesc.
+ GfxTopology topology = GfxTopology::Triangles; ///< Triangles or lines. @see PipelineDesc.
BatchBreak break_reason = BatchBreak::RunStart; ///< Why this draw call started.
u8 texture_count = 0;
@@ -391,6 +392,7 @@ struct DrawCommand {
if (material_id != next.material_id) return BatchBreak::Material;
if (cull != next.cull) return BatchBreak::Cull;
if (depth_bias != next.depth_bias) return BatchBreak::Cull;
+ if (topology != next.topology) return BatchBreak::Layout;
if (state_flags != next.state_flags) return BatchBreak::State;
if (state_flags & CMD_STATE_SCISSOR) {
if (scissor != next.scissor) return BatchBreak::Scissor;
@@ -420,6 +422,7 @@ struct DrawCommand {
if (depth_write != next.depth_write) return BatchBreak::Depth;
if (cull != next.cull) return BatchBreak::Cull;
if (depth_bias != next.depth_bias) return BatchBreak::Cull;
+ if (topology != next.topology) return BatchBreak::Layout;
if (state_flags != next.state_flags) return BatchBreak::State;
if (state_flags & CMD_STATE_SCISSOR) {
if (scissor != next.scissor) return BatchBreak::Scissor;
diff --git a/src/esengine/renderer/draw/DrawList.cpp b/src/esengine/renderer/draw/DrawList.cpp
index c04eefaff..50cc6f05a 100644
--- a/src/esengine/renderer/draw/DrawList.cpp
+++ b/src/esengine/renderer/draw/DrawList.cpp
@@ -53,7 +53,8 @@ bool joinBatchIndexRanges(TransientBufferPool& pool, DrawCommand& head, DrawComm
&& cmd.vertex_byte_offset <= vertexBytes
&& cmd.vertex_count <= (vertexBytes - cmd.vertex_byte_offset) / stride;
};
- if (!owned(head) || !owned(next) || head.depth_bias != next.depth_bias) return false;
+ if (!owned(head) || !owned(next) || head.depth_bias != next.depth_bias
+ || head.topology != next.topology) return false;
u32 at;
if (head.index_offset + head.index_count != used) {
if (!pool.copyIndexRange(LayoutId::Batch, head.index_offset, head.index_count, at)) return false;
@@ -392,6 +393,7 @@ void DrawList::execute(GfxDevice& device, TransientBufferPool& buffers,
desc.cullEnabled = cmd.cull != 0;
desc.cullFront = cmd.cull == 2;
desc.depthBias = cmd.depth_bias;
+ desc.topology = cmd.topology;
desc.alphaToCoverage = !desc.blendEnabled && materials.alphaIsCoverage(cmd.material_id);
if (lastHandle == PipelineHandle::Invalid || !(desc == lastDesc)) {
diff --git a/src/esengine/renderer/frame/ViewShading.hpp b/src/esengine/renderer/frame/ViewShading.hpp
index 18a9cb868..ac8c3d0ec 100644
--- a/src/esengine/renderer/frame/ViewShading.hpp
+++ b/src/esengine/renderer/frame/ViewShading.hpp
@@ -2,7 +2,7 @@
// 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.
+ * @brief How a view shades the meshes it draws: as authored, clay, flat albedo, or wireframe.
*/
#pragma once
@@ -26,9 +26,11 @@ enum class ShadingMode : u8 {
Clay = 1,
/// Base colour and texture with no light and no material: what was painted.
Albedo = 2,
+ /// A dark surface with every triangle edge drawn on it, hidden edges hidden.
+ Wireframe = 3,
};
-inline constexpr u8 kShadingModeCount = 3;
+inline constexpr u8 kShadingModeCount = 4;
/**
* @brief The mode each view asked for. A view that never asked is Shaded, which is
diff --git a/src/esengine/renderer/plugins/MeshPlugin.cpp b/src/esengine/renderer/plugins/MeshPlugin.cpp
index 1a700e11e..f154aa892 100644
--- a/src/esengine/renderer/plugins/MeshPlugin.cpp
+++ b/src/esengine/renderer/plugins/MeshPlugin.cpp
@@ -261,6 +261,14 @@ 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.
*/
+/// The surface of a wireframe view and the ink of its edges. Neutral, so a wireframe says
+/// nothing about anyone's colours.
+constexpr glm::vec4 kWireFill{0.075f, 0.075f, 0.08f, 1.0f};
+constexpr glm::vec4 kWireInk{0.9f, 0.9f, 0.9f, 1.0f};
+/// How far behind the edges the surface is pushed, in depth units (positive is away). Level with
+/// them it would win every pixel and the wireframe would be a handful of dashes.
+constexpr i16 kWireFillBias = 4;
+
/**
* @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
@@ -271,7 +279,13 @@ u32 meshVariant(bool normals, bool lit, bool normalMapped, bool skinned, bool de
void applyShading(ecs::MeshRenderer& mesh, ShadingMode mode) {
mesh.material = 0;
mesh.normalMap = {};
- if (mode == ShadingMode::Clay) {
+ if (mode == ShadingMode::Wireframe) {
+ // The surface the edges stand on: dark, unlit, opaque so it hides what is behind it.
+ mesh.texture = {};
+ mesh.color = kWireFill;
+ mesh.lit = false;
+ mesh.opaque = true;
+ } else if (mode == ShadingMode::Clay) {
mesh.texture = {};
mesh.color = glm::vec4(0.74f, 0.74f, 0.76f, 1.0f);
mesh.lit = true;
@@ -790,7 +804,30 @@ void MeshPlugin::collect(RenderCollectContext& collect_ctx) {
key.vertexBuffer = resident->vertexBuffer;
key.indexBuffer = resident->indexBuffer;
key.vertexLayout = resident->layout;
+ const bool wire = shading == ShadingMode::Wireframe;
+ if (wire) key.depthBias = kWireFillBias;
pushBatchDraw(draw_list, clips, instOffset, 0, 0, resident->indexCount, key);
+ // The edges, as a second draw of the same instance with its own ink: same
+ // vertices, the mesh's line list, tested against the surface just drawn.
+ if (wire && resident->hasEdges()) {
+ const u32 edgeOffset = buffers.allocVertices(LayoutId::MeshInstance,
+ MESH_INSTANCE_STRIDE);
+ auto* records = buffers.vertexData(LayoutId::MeshInstance);
+ std::memcpy(records + edgeOffset, records + instOffset, MESH_INSTANCE_STRIDE);
+ std::memcpy(records + edgeOffset + MESH_INSTANCE_TEXEL_TINT * 16, &kWireInk, 16);
+ BatchDrawKey edges = key;
+ edges.indexBuffer = resident->edgeIndexBuffer;
+ edges.topology = GfxTopology::Lines;
+ edges.depthBias = 0;
+ edges.depthTest = true;
+ edges.depthWrite = false;
+ // Blended at full alpha: what puts it in the stage AFTER the surface it
+ // is drawn on (a depth layer derives the stage from the blend, and an
+ // opaque line would sort among the surfaces and write depth).
+ edges.blend = BlendMode::Normal;
+ edges.stage = RenderStage::Transparent;
+ pushBatchDraw(draw_list, clips, edgeOffset, 0, 0, resident->edgeIndexCount, edges);
+ }
}
continue;
}
diff --git a/src/esengine/renderer/rhi/GLDevice.cpp b/src/esengine/renderer/rhi/GLDevice.cpp
index c4c52dfa3..bb69d5aeb 100644
--- a/src/esengine/renderer/rhi/GLDevice.cpp
+++ b/src/esengine/renderer/rhi/GLDevice.cpp
@@ -985,6 +985,7 @@ void GLDevice::backendSetPipeline(u32 id, const PipelineDesc& desc) {
}
current_pipeline_id_ = id;
+ current_topology_ = desc.topology;
current_stencil_mode_ = desc.stencil;
current_layout_ = static_cast<u32>(desc.vertexLayout);
}
@@ -1039,23 +1040,28 @@ void GLDevice::backendInvalidatePipelineCache() {
// Draw Calls
// =============================================================================
+/** The mode the bound pipeline's topology means. */
+u32 GLDevice::glPrimitiveMode() const {
+ return current_topology_ == GfxTopology::Lines ? GL_LINES : GL_TRIANGLES;
+}
+
void GLDevice::drawElements(u32 indexCount, GfxDataType indexType, u32 byteOffset) {
if (!isDeviceUsable()) return;
prepareVertexState();
- glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(indexCount), toGLDataType(indexType),
+ glDrawElements(glPrimitiveMode(), static_cast<GLsizei>(indexCount), toGLDataType(indexType),
reinterpret_cast<const void*>(static_cast<uintptr_t>(byteOffset)));
}
void GLDevice::drawArrays(u32 first, u32 vertexCount) {
if (!isDeviceUsable()) return;
prepareVertexState();
- glDrawArrays(GL_TRIANGLES, static_cast<GLint>(first), static_cast<GLsizei>(vertexCount));
+ glDrawArrays(glPrimitiveMode(), static_cast<GLint>(first), static_cast<GLsizei>(vertexCount));
}
void GLDevice::drawElementsInstanced(u32 indexCount, GfxDataType indexType, u32 byteOffset, u32 instanceCount) {
if (!isDeviceUsable()) return;
prepareVertexState();
- glDrawElementsInstanced(GL_TRIANGLES, static_cast<GLsizei>(indexCount), toGLDataType(indexType),
+ glDrawElementsInstanced(glPrimitiveMode(), static_cast<GLsizei>(indexCount), toGLDataType(indexType),
reinterpret_cast<const void*>(static_cast<uintptr_t>(byteOffset)),
static_cast<GLsizei>(instanceCount));
}
diff --git a/src/esengine/renderer/rhi/GLDevice.hpp b/src/esengine/renderer/rhi/GLDevice.hpp
index eb6d10654..0c1237c51 100644
--- a/src/esengine/renderer/rhi/GLDevice.hpp
+++ b/src/esengine/renderer/rhi/GLDevice.hpp
@@ -131,6 +131,8 @@ protected:
void backendDeleteVertexLayout(u32 id) override;
void backendSetPipeline(u32 id, const PipelineDesc& desc) override;
+ /** The GL primitive mode of the bound pipeline's topology. */
+ u32 glPrimitiveMode() const;
void backendInvalidatePipelineCache() override;
bool backendCreateFramebuffer(u32 id, const FramebufferDesc& desc) override;
@@ -210,6 +212,7 @@ private:
void bindUniformSlot(u32 slot, u32 name);
u32 current_pipeline_id_ = 0;
+ GfxTopology current_topology_ = GfxTopology::Triangles;
GfxStencilMode current_stencil_mode_ = GfxStencilMode::Off;
// Redundant-state caches: a pipeline switch sharing the program or blend func
// skips the FFI-crossing GL call. 0xFF is an out-of-range BlendMode, so the
diff --git a/src/esengine/renderer/rhi/PipelineState.hpp b/src/esengine/renderer/rhi/PipelineState.hpp
index 2c532fdab..c33551d4d 100644
--- a/src/esengine/renderer/rhi/PipelineState.hpp
+++ b/src/esengine/renderer/rhi/PipelineState.hpp
@@ -45,6 +45,15 @@ inline bool writesStencil(GfxStencilMode mode) {
|| mode == GfxStencilMode::Decrement || mode == GfxStencilMode::Zero;
}
+/**
+ * @brief How a pipeline's indices assemble into primitives. Baked into the pipeline, as WebGPU
+ * bakes it, so a draw call never states it: whoever binds a pipeline has said it.
+ */
+enum class GfxTopology : u8 {
+ Triangles, ///< Every three indices a triangle: all geometry the engine draws.
+ Lines, ///< Every two indices a line segment: a mesh's edges, for a diagnostic view.
+};
+
/**
* @brief Immutable description of a draw pipeline. Equality keys the pipeline cache, so
* two draws with the same description share one PipelineHandle.
@@ -66,6 +75,7 @@ struct PipelineDesc {
/// Output alpha becomes multisample coverage (a cutout's feathered edge). Only
/// meaningful on an opaque draw into a multisampled target; ignored elsewhere.
bool alphaToCoverage = false;
+ GfxTopology topology = GfxTopology::Triangles;
bool operator==(const PipelineDesc&) const = default;
};
diff --git a/src/esengine/renderer/webgpu/WebGPUDevice.cpp b/src/esengine/renderer/webgpu/WebGPUDevice.cpp
index 45fe3e9ca..a4975f6a6 100644
--- a/src/esengine/renderer/webgpu/WebGPUDevice.cpp
+++ b/src/esengine/renderer/webgpu/WebGPUDevice.cpp
@@ -1307,7 +1307,8 @@ WGPURenderPipeline WebGPUDevice::ensurePipeline(u32 id) {
pd.vertex.entryPoint = sv("vs_main");
pd.vertex.bufferCount = slotCount;
pd.vertex.buffers = slots;
- pd.primitive.topology = WGPUPrimitiveTopology_TriangleList;
+ pd.primitive.topology = desc.topology == GfxTopology::Lines ? WGPUPrimitiveTopology_LineList
+ : WGPUPrimitiveTopology_TriangleList;
pd.primitive.frontFace = WGPUFrontFace_CCW;
pd.primitive.cullMode = toWGPUCullMode(desc.cullEnabled, desc.cullFront);
// The pass's count, which WebGPU validates against the attachment: a pipeline
diff --git a/src/esengine/resource/Mesh.hpp b/src/esengine/resource/Mesh.hpp
index ca49b495a..898cd18ad 100644
--- a/src/esengine/resource/Mesh.hpp
+++ b/src/esengine/resource/Mesh.hpp
@@ -61,6 +61,19 @@ public:
u32 indexCount = 0;
+ /**
+ * The mesh's own edges as line-list indices into the same vertices, one pair per
+ * distinct edge. Derived from `indices` when the mesh is realized, and only while
+ * the manager is asked for diagnostic geometry (an editor's wireframe view): a
+ * shipped game spends nothing on it. Invalid otherwise.
+ */
+ resource::IndexBufferHandle edges;
+ BufferHandle edgeIndexBuffer = BufferHandle::Invalid;
+ u32 edgeIndexCount = 0;
+
+ /** Whether the edges can be drawn. */
+ bool hasEdges() const { return edgeIndexBuffer != BufferHandle::Invalid && edgeIndexCount > 0; }
+
/** Set at mint by the producer that created this mesh; never inferred later.
* Defaulted to the answer that promises nothing, so a mesh reaching the pool
* without one is never mistaken for recoverable. */
diff --git a/src/esengine/resource/MeshEdges.hpp b/src/esengine/resource/MeshEdges.hpp
new file mode 100644
index 000000000..f96363cf7
--- /dev/null
+++ b/src/esengine/resource/MeshEdges.hpp
@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
+/**
+ * @file MeshEdges.hpp
+ * @brief The distinct edges of a triangle list, as the line list a wireframe draws.
+ */
+#pragma once
+
+#include "../core/Types.hpp"
+
+#include <algorithm>
+#include <vector>
+
+namespace esengine {
+
+/**
+ * @brief Index pairs, one per distinct edge, in ascending order of (low, high) vertex.
+ * @details An edge two triangles share is one line, not two: drawn twice a line is brighter,
+ * and a wireframe whose interior outshines its rim reads wrong. Edges are compared
+ * by vertex index, so a seam that splits one vertex in two stays two edges.
+ */
+inline std::vector<u32> distinctMeshEdges(ConstSpan<u32> indices) {
+ std::vector<u64> keys;
+ keys.reserve(indices.size());
+ for (usize t = 0; t + 2 < indices.size(); t += 3) {
+ for (u32 k = 0; k < 3; ++k) {
+ const u32 a = indices[t + k], b = indices[t + (k + 1) % 3];
+ keys.push_back((static_cast<u64>(std::min(a, b)) << 32) | std::max(a, b));
+ }
+ }
+ std::sort(keys.begin(), keys.end());
+ keys.erase(std::unique(keys.begin(), keys.end()), keys.end());
+ std::vector<u32> lines;
+ lines.reserve(keys.size() * 2);
+ for (const u64 key : keys) {
+ lines.push_back(static_cast<u32>(key >> 32));
+ lines.push_back(static_cast<u32>(key & 0xFFFFFFFFu));
+ }
+ return lines;
+}
+
+} // namespace esengine
diff --git a/src/esengine/resource/ResourceManager.cpp b/src/esengine/resource/ResourceManager.cpp
index 8f49a7eb1..230572d3d 100644
--- a/src/esengine/resource/ResourceManager.cpp
+++ b/src/esengine/resource/ResourceManager.cpp
@@ -13,6 +13,7 @@
#include "../core/Half.hpp"
#include "ResourceManager.hpp"
+#include "MeshEdges.hpp"
#include "ShaderParser.hpp"
#include "../text/BitmapFont.hpp"
#include "../core/Log.hpp"
@@ -32,7 +33,8 @@ namespace {
bool meshOwed(const Mesh& mesh, const std::vector<GfxOwedContent>& owed) {
for (const GfxOwedContent& entry : owed) {
if (entry.kind == GfxOwedContent::Kind::Buffer
- && (entry.id == static_cast<u32>(mesh.vertexBuffer) || entry.id == static_cast<u32>(mesh.indexBuffer))) {
+ && (entry.id == static_cast<u32>(mesh.vertexBuffer) || entry.id == static_cast<u32>(mesh.indexBuffer)
+ || (mesh.hasEdges() && entry.id == static_cast<u32>(mesh.edgeIndexBuffer)))) {
return true;
}
if (entry.kind == GfxOwedContent::Kind::Texture && entry.id == static_cast<u32>(mesh.morphTexture)) {
@@ -589,6 +591,7 @@ bool ResourceManager::realizeMesh(Mesh& mesh, ConstSpan<u8> vertexBytes, ConstSp
// realization it still had.
const VertexBufferHandle previousVertices = mesh.vertices;
const IndexBufferHandle previousIndices = mesh.indices;
+ const IndexBufferHandle previousEdges = mesh.edges;
// A replayable mesh is refilled by its source; one built in this process has
// no other copy, so the device keeps it.
@@ -611,10 +614,30 @@ bool ResourceManager::realizeMesh(Mesh& mesh, ConstSpan<u8> vertexBytes, ConstSp
return false;
}
+ // The edges follow the triangles' own content policy, and a failure to make them
+ // costs the wireframe view, never the mesh.
+ IndexBufferHandle edgeHandle;
+ u32 edgeCount = 0;
+ if (meshEdges_) {
+ const std::vector<u32> lines = distinctMeshEdges(indices);
+ edgeHandle = createIndexBuffer(content, ConstSpan<u32>(lines));
+ const IndexBuffer* eb = getIndexBuffer(edgeHandle);
+ if (eb && eb->handle() != BufferHandle::Invalid) {
+ edgeCount = static_cast<u32>(lines.size());
+ } else {
+ releaseIndexBuffer(edgeHandle);
+ edgeHandle = IndexBufferHandle();
+ }
+ }
+
releaseVertexBuffer(previousVertices);
releaseIndexBuffer(previousIndices);
+ releaseIndexBuffer(previousEdges);
device_->deleteVertexLayout(mesh.layout);
+ mesh.edges = edgeHandle;
+ mesh.edgeIndexBuffer = edgeCount > 0 ? getIndexBuffer(edgeHandle)->handle() : BufferHandle::Invalid;
+ mesh.edgeIndexCount = edgeCount;
mesh.vertices = vertices;
mesh.indices = indices_handle;
mesh.vertexBuffer = vb->handle();
@@ -779,6 +802,7 @@ void ResourceManager::releaseMesh(MeshHandle handle) {
if (device_) device_->deleteVertexLayout(mesh->layout);
releaseVertexBuffer(mesh->vertices);
releaseIndexBuffer(mesh->indices);
+ releaseIndexBuffer(mesh->edges);
// The delta texture IS the mesh's own — nothing shares it, unlike the layout.
if (mesh->morphTexture != esengine::TextureHandle::Invalid && device_) {
device_->deleteTexture(mesh->morphTexture);
diff --git a/src/esengine/resource/ResourceManager.hpp b/src/esengine/resource/ResourceManager.hpp
index 3e6924a95..6e751315f 100644
--- a/src/esengine/resource/ResourceManager.hpp
+++ b/src/esengine/resource/ResourceManager.hpp
@@ -510,6 +510,15 @@ public:
const glm::vec3& localMin, const glm::vec3& localMax,
ConstSpan<f32> inverseBind = {}, const MeshMorphSource& morph = {});
+ /**
+ * @brief Whether meshes realized FROM NOW ON also get an edge buffer.
+ * @details Diagnostic geometry for a wireframe view, off by default because it is a
+ * second index buffer per mesh. Set before the assets load: a mesh realized
+ * earlier has no edges, and a view that wants them draws it filled.
+ */
+ void setMeshEdgeBuffers(bool enabled) { meshEdges_ = enabled; }
+ bool meshEdgeBuffers() const { return meshEdges_; }
+
/** @brief The mesh a handle names, or null. */
Mesh* getMesh(MeshHandle handle);
const Mesh* getMesh(MeshHandle handle) const;
@@ -710,6 +719,7 @@ private:
ResourcePool<Texture> textures_;
ResourcePool<VertexBuffer> vertexBuffers_;
ResourcePool<IndexBuffer> indexBuffers_;
+ bool meshEdges_ = false;
ResourcePool<Mesh> meshes_;
ResourcePool<Environment> environments_;
ResourcePool<ProbeVolume> probeVolumes_;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 616b2f1f4..1a59cfbdb 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -336,6 +336,15 @@ target_include_directories(test_view_shading PRIVATE
)
add_test(NAME test_view_shading COMMAND test_view_shading)
+# The edges a wireframe draws, from a triangle list. Header-only, so no device: a pixel gate says
+# the lines came out wrong, this says whether an edge was doubled, dropped or split by a seam.
+add_executable(test_mesh_edges resource/test_mesh_edges.cpp)
+target_include_directories(test_mesh_edges PRIVATE
+ ${CMAKE_SOURCE_DIR}/src
+ ${CMAKE_SOURCE_DIR}/third_party/glm
+)
+add_test(NAME test_mesh_edges COMMAND test_mesh_edges)
+
# 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 grid
diff --git a/tests/renderer/test_view_shading.cpp b/tests/renderer/test_view_shading.cpp
index b8377823e..ec384a627 100644
--- a/tests/renderer/test_view_shading.cpp
+++ b/tests/renderer/test_view_shading.cpp
@@ -21,9 +21,9 @@ int main() {
CHECK(shading.count() == 0, "an untouched store holds nothing");
shading.set(7, ShadingMode::Clay);
- shading.set(9, ShadingMode::Albedo);
+ shading.set(9, ShadingMode::Wireframe);
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(9) == ShadingMode::Wireframe, "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");
@@ -31,7 +31,7 @@ int main() {
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");
+ CHECK(static_cast<u8>(ShadingMode::Wireframe) + 1 == kShadingModeCount, "the modes the bindings accept are the ones the enum declares");
if (g_failures) {
std::printf("%d failure(s)\n", g_failures);
diff --git a/tests/resource/test_mesh_edges.cpp b/tests/resource/test_mesh_edges.cpp
new file mode 100644
index 000000000..5830fd835
--- /dev/null
+++ b/tests/resource/test_mesh_edges.cpp
@@ -0,0 +1,57 @@
+// The edges a wireframe draws: every distinct edge of a triangle list once, in order, and
+// nothing a seam or a shared edge could double.
+
+#include "esengine/resource/MeshEdges.hpp"
+
+#include <cstdio>
+#include <vector>
+
+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() {
+ const std::vector<u32> none;
+ CHECK(distinctMeshEdges(none).empty(), "no triangles, no edges");
+
+ const std::vector<u32> one = {0, 1, 2};
+ const auto e1 = distinctMeshEdges(one);
+ CHECK(e1.size() == 6, "one triangle has three edges");
+ CHECK((e1 == std::vector<u32>{0, 1, 0, 2, 1, 2}), "listed low vertex first, in ascending order");
+
+ // Two triangles sharing the 1-2 edge: a quad. Five edges, the diagonal once.
+ const std::vector<u32> quad = {0, 1, 2, 2, 1, 3};
+ const auto eq = distinctMeshEdges(quad);
+ CHECK(eq.size() == 10, "a quad is five edges: four sides and one diagonal");
+ int diagonal = 0;
+ for (usize i = 0; i < eq.size(); i += 2) diagonal += (eq[i] == 1 && eq[i + 1] == 2) ? 1 : 0;
+ CHECK(diagonal == 1, "an edge two triangles share is one line, not two");
+
+ // The same quad with the diagonal's vertices split by a seam (2 and 4 are one place, 1 and 5 too):
+ // vertex indices differ, so the two copies of the diagonal are two edges. That is a rim.
+ const std::vector<u32> seamed = {0, 1, 2, 4, 5, 3};
+ CHECK(distinctMeshEdges(seamed).size() == 12, "a seam that splits vertices keeps both copies of the edge");
+
+ // A triangle count that is not a multiple of three drops the trailing indices rather than reading past.
+ const std::vector<u32> ragged = {0, 1, 2, 3, 4};
+ CHECK(distinctMeshEdges(ragged).size() == 6, "trailing indices short of a triangle are ignored");
+
+ // A cube of twelve triangles has eighteen edges (twelve sides and six face diagonals).
+ const std::vector<u32> cube = {
+ 0, 1, 2, 0, 2, 3, 4, 6, 5, 4, 7, 6, 0, 5, 1, 0, 4, 5,
+ 3, 2, 6, 3, 6, 7, 0, 3, 7, 0, 7, 4, 1, 5, 6, 1, 6, 2,
+ };
+ CHECK(distinctMeshEdges(cube).size() == 36, "a closed cube of twelve triangles has eighteen edges");
+
+ if (g_failures) {
+ std::printf("%d failure(s)\n", g_failures);
+ return 1;
+ }
+ std::printf("all mesh edge checks passed\n");
+ return 0;
+}
diff --git a/tools/releaseNotes.mjs b/tools/releaseNotes.mjs
index 280cedf2a..42c837aa9 100644
--- a/tools/releaseNotes.mjs
+++ b/tools/releaseNotes.mjs
@@ -114,6 +114,8 @@ export const NOTED = {
{ 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(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(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.ts
index 070035f01..2767f0761 100644
--- a/tools/render-host/host.ts
+++ b/tools/render-host/host.ts
@@ -148,6 +148,8 @@ async function boot(): Promise<void> {
wasmBaseUrl: '/wasm',
});
app.enableStats();
+ // The editor's engine asks for edge buffers before its assets load; so does this host.
+ module.renderer_setMeshEdgeBuffers?.(true);
if (runtimeTextures) {
app.getResource(Assets).getTextureLoader().setPixelDecoder(async (path) => {
const res = await fetch(path);
diff --git a/tools/render-host/run.mjs b/tools/render-host/run.mjs
index 32d485465..4d6bd04f7 100644
--- a/tools/render-host/run.mjs
+++ b/tools/render-host/run.mjs
@@ -1133,9 +1133,9 @@ 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) };
}
- // ESTELLA_VERIFY_SHADING: authored A, clay C, albedo L, authored again A2, through one eye.
+ // ESTELLA_VERIFY_SHADING: authored A, clay C, albedo L, wireframe W, authored again A2.
// 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.
+ // wireframe is neutral lines on a dark surface; A2 == A byte for byte afterwards.
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); })()`);
@@ -1165,14 +1165,18 @@ app.whenReady().then(async () => {
const C = await stats('C');
await api(`api.setViewShading('albedo')`);
const L = await stats('L');
+ await api(`api.setViewShading('wireframe')`);
+ const W = await stats('W');
const dClay = await diff('A', 'C');
const dAlbedo = await diff('A', 'L');
+ const dWire = await diff('A', 'W');
await api(`api.setViewShading('shaded')`);
await stats('A2');
const back = await diff('A', 'A2');
- shading = { A, C, L, dClay, dAlbedo, back,
+ shading = { A, C, L, W, dClay, dAlbedo, dWire, 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 };
+ && 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);
} catch (e) {