webgpu 1.2.2.dev0__py3-none-any.whl → 1.2.3.dev0__py3-none-any.whl

webgpu/input_handler.py

@@ -7,7 +7,7 @@ class InputHandler:
 
     class Modifiers:
         def __init__(
-            self, alt: bool | None = False, shift: bool | None = False, ctrl: bool | None = False
+            self, alt: bool | None = None, shift: bool | None = None, ctrl: bool | None = None
         ):
             self.alt = alt
             self.shift = shift
@@ -61,9 +61,9 @@ class InputHandler:
         self,
         event: str,
         func: Callable,
-        alt: bool | None = False,
-        shift: bool | None = False,
-        ctrl: bool | None = False,
+        alt: bool | None = None,
+        shift: bool | None = None,
+        ctrl: bool | None = None,
     ):
         if event not in self._callbacks:
             self._callbacks[event] = []
@@ -87,42 +87,42 @@ class InputHandler:
                     func(ev, *args)
 
     def on_dblclick(
-        self, func, alt: bool | None = False, shift: bool | None = False, ctrl: bool | None = False
+        self, func, alt: bool | None = None, shift: bool | None = None, ctrl: bool | None = None
     ):
         self.on("dblclick", func, alt, shift, ctrl)
 
     def on_click(
-        self, func, alt: bool | None = False, shift: bool | None = False, ctrl: bool | None = False
+        self, func, alt: bool | None = None, shift: bool | None = None, ctrl: bool | None = None
     ):
         self.on("click", func, alt, shift, ctrl)
 
     def on_mousedown(
-        self, func, alt: bool | None = False, shift: bool | None = False, ctrl: bool | None = False
+        self, func, alt: bool | None = None, shift: bool | None = None, ctrl: bool | None = None
     ):
         self.on("mousedown", func, alt, shift, ctrl)
 
     def on_mouseup(
-        self, func, alt: bool | None = False, shift: bool | None = False, ctrl: bool | None = False
+        self, func, alt: bool | None = None, shift: bool | None = None, ctrl: bool | None = None
     ):
         self.on("mouseup", func, alt, shift, ctrl)
 
     def on_mouseout(
-        self, func, alt: bool | None = False, shift: bool | None = False, ctrl: bool | None = False
+        self, func, alt: bool | None = None, shift: bool | None = None, ctrl: bool | None = None
     ):
         self.on("mouseout", func, alt, shift, ctrl)
 
     def on_wheel(
-        self, func, alt: bool | None = False, shift: bool | None = False, ctrl: bool | None = False
+        self, func, alt: bool | None = None, shift: bool | None = None, ctrl: bool | None = None
     ):
         self.on("wheel", func, alt, shift, ctrl)
 
     def on_mousemove(
-        self, func, alt: bool | None = False, shift: bool | None = False, ctrl: bool | None = False
+        self, func, alt: bool | None = None, shift: bool | None = None, ctrl: bool | None = None
     ):
         self.on("mousemove", func, alt, shift, ctrl)
 
     def on_drag(
-        self, func, alt: bool | None = False, shift: bool | None = False, ctrl: bool | None = False
+        self, func, alt: bool | None = None, shift: bool | None = None, ctrl: bool | None = None
     ):
         self.on("drag", func, alt, shift, ctrl)
 

webgpu/labels.py

@@ -3,7 +3,7 @@ import numpy as np
 from .font import Font
 from .renderer import Renderer, RenderOptions, check_timestamp
 from .uniforms import Binding
-from .utils import BufferBinding, buffer_from_array, read_shader_file
+from .utils import BufferBinding, UniformBinding, buffer_from_array, uniform_from_array, read_shader_file
 from .webgpu_api import *
 
 
@@ -18,8 +18,11 @@ class Labels(Renderer):
     @param positions: list of positions to render the labels at
     @param apply_camera: whether to apply the camera transformation to the labels
     @param h_align: horizontal alignment of the labels. Can be one of: left, l, center, c, right, r
-    @param v_align: horizontal alignment of the labels. Can be one of: bottom, b, center, c, top, t
+    @param v_align: vertical alignment of the labels. Can be one of: bottom, b, center, c, top, t
     @param font_size: font size
+    @param overlay: dict with 'corner' (x,y) and 'scale' for fixed-screen overlay mode, or None
+    @param normals: per-label normals for visibility culling in overlay mode, or None
+    @param colors: per-label RGBA colors (list of [r,g,b,a] floats 0-1), or None (renders black)
 
     If any of apply_camera, h_align, or v_align is a list, it must have the same length as labels.
     """
@@ -32,6 +35,9 @@ class Labels(Renderer):
         h_align: str | list[str] = "left",
         v_align: str | list[str] = "bottom",
         font_size=20,
+        overlay: dict | None = None,
+        normals: list | None = None,
+        colors: list | None = None,
     ):
         super().__init__()
         self.labels = labels
@@ -40,15 +46,22 @@ class Labels(Renderer):
         self.apply_camera = apply_camera
         self.h_align = h_align
         self.v_align = v_align
+        self.overlay = overlay
+        self.normals = normals
+        self.colors = colors
         self.buffer = None
-
+        self._overlay_buf = None
         self.font = None
 
+        if colors is not None:
+            self.fragment_entry_point = "fragmentFontColor"
+
     def update(self, options: RenderOptions):
         n_chars = sum(len(label) for label in self.labels)
         n_labels = len(self.labels)
         self.n_vertices = 6
         self.n_instances = n_chars
+
         char_t = np.dtype(
             [
                 ("itext", np.uint32),
@@ -57,27 +70,22 @@ class Labels(Renderer):
             ]
         )
         char_data = np.zeros(n_chars, dtype=char_t)
+
+        # 8 u32s per text: pos(3f) + packed(1u) + normal(3f) + color_packed(1u)
         text_t = np.dtype(
             [
                 ("pos", np.float32, 3),
-                ("length", np.uint16),
-                ("apply_camera", np.uint8),
-                ("alignment", np.uint8),
+                ("packed", np.uint32),
+                ("normal", np.float32, 3),
+                ("color_packed", np.uint32),
             ]
         )
         text_data = np.zeros(n_labels, dtype=text_t)
 
         align_map = {
-            "c": 1,
-            "center": 1,
-            "r": 2,
-            "right": 2,
-            "t": 2,
-            "top": 2,
-            "b": 0,
-            "bottom": 0,
-            "l": 0,
-            "left": 0,
+            "c": 1, "center": 1,
+            "r": 2, "right": 2, "t": 2, "top": 2,
+            "b": 0, "bottom": 0, "l": 0, "left": 0,
         }
 
         if self.font is None:
@@ -88,21 +96,38 @@ class Labels(Renderer):
         char_map = self.font.atlas.char_map
 
         ichar = 0
-        for i, label, pos in zip(range(len(self.labels)), self.labels, self.positions):
+        for i, (label, pos) in enumerate(zip(self.labels, self.positions)):
             h_align = self.h_align if isinstance(self.h_align, str) else self.h_align[i]
             v_align = self.v_align if isinstance(self.v_align, str) else self.v_align[i]
             align = align_map[h_align] + 4 * align_map[v_align]
-            apply_camera = (
-                self.apply_camera if isinstance(self.apply_camera, bool) else self.apply_camera[i]
-            )
+
+            if self.overlay is not None:
+                apply_camera = 2
+            elif isinstance(self.apply_camera, bool):
+                apply_camera = int(self.apply_camera)
+            else:
+                apply_camera = int(self.apply_camera[i])
 
             if len(pos) == 2:
                 pos = (*pos, 0)
 
             text_data[i]["pos"] = pos
-            text_data[i]["length"] = len(label)
-            text_data[i]["apply_camera"] = apply_camera
-            text_data[i]["alignment"] = align
+            text_data[i]["packed"] = (
+                (len(label) & 0xFFFF)
+                | ((apply_camera & 0xFF) << 16)
+                | ((align & 0xFF) << 24)
+            )
+
+            if self.normals is not None:
+                text_data[i]["normal"] = self.normals[i]
+
+            if self.colors is not None:
+                c = self.colors[i]
+                r = int(c[0] * 255)
+                g = int(c[1] * 255)
+                b = int(c[2] * 255)
+                a = int(c[3] * 255) if len(c) > 3 else 255
+                text_data[i]["color_packed"] = r | (g << 8) | (b << 16) | (a << 24)
 
             i0 = ichar
             for c in label:
@@ -112,13 +137,22 @@ class Labels(Renderer):
                 ichar += 1
 
         data = (
-            np.array([len(self.labels)], dtype=np.uint32).tobytes()
+            np.array([n_labels], dtype=np.uint32).tobytes()
             + text_data.tobytes()
             + char_data.tobytes()
         )
 
         self.buffer = buffer_from_array(data, BufferUsage.STORAGE | BufferUsage.COPY_DST, "labels", self.buffer)
 
+        # Overlay uniform
+        if self.overlay is not None:
+            corner = self.overlay["corner"]
+            scale = self.overlay["scale"]
+            overlay_data = np.array([corner[0], corner[1], scale, 0.0], dtype=np.float32)
+        else:
+            overlay_data = np.array([0.0, 0.0, 0.0, 0.0], dtype=np.float32)
+        self._overlay_buf = uniform_from_array(overlay_data, label="overlay_uni", reuse=self._overlay_buf)
+
     def get_shader_code(self):
         return read_shader_file("text.wgsl")
 
@@ -126,4 +160,5 @@ class Labels(Renderer):
         return [
             *self.font.get_bindings(),
             BufferBinding(Binding.TEXT, self.buffer),
+            UniformBinding(31, self._overlay_buf),
         ]

webgpu/renderer.py

@@ -76,6 +76,11 @@ class RenderOptions:
     def __init__(self, camera: Camera, light: Light):
         self.light = light
         self.camera = camera
+        self._extra_binding_providers = []
+
+    def add_bindings(self, provider):
+        """Register an object with a get_bindings() method (e.g. a UniformBase)."""
+        self._extra_binding_providers.append(provider)
 
     def set_canvas(self, canvas: Canvas):
         self.canvas = canvas
@@ -90,9 +95,13 @@ class RenderOptions:
         self.light.update(self)
 
     def get_bindings(self):
+        extra = []
+        for p in self._extra_binding_providers:
+            extra.extend(p.get_bindings())
         return [
             *self.light.get_bindings(),
             *self.camera.get_bindings(),
+            *extra,
         ]
 
     def begin_render_pass(self, **kwargs):
@@ -163,6 +172,7 @@ class BaseRenderer:
     shader_defines: dict[str, str] = None
     _id = None
     _on_select: list[Callable[[SelectEvent], None]]
+    transparent: bool = False
 
     def __init__(self, label=None):
         self._id = next(_id_counter)
@@ -280,9 +290,18 @@ class MultipleRenderer(BaseRenderer):
             r.create_render_pipeline(options)
 
     def render(self, options: RenderOptions) -> None:
+        self.render_opaque(options)
+        self.render_transparent(options)
+
+    def render_opaque(self, options: RenderOptions) -> None:
+        for r in self.render_objects:
+            if r.active:
+                r.render_opaque(options)
+
+    def render_transparent(self, options: RenderOptions) -> None:
         for r in self.render_objects:
             if r.active:
-                r.render(options)
+                r.render_transparent(options)
 
     def select(self, options: RenderOptions, x: int, y: int) -> None:
         for r in self.render_objects:
@@ -306,6 +325,10 @@ class MultipleRenderer(BaseRenderer):
     def on_select_set(self):
         return any(r.on_select_set for r in self.render_objects)
 
+    @property
+    def transparent(self):
+        return any(r.transparent for r in self.render_objects if r.active)
+
 
 class Renderer(BaseRenderer):
     """Base class for renderer classes"""
@@ -320,61 +343,123 @@ class Renderer(BaseRenderer):
     select_entry_point: str = "fragment_select_default"
     vertex_buffer_layouts: list[VertexBufferLayout] = []
     vertex_buffers: list[Buffer] = []
+    transparent: bool = False
 
     _last_bindings: list[BaseBinding] = []
+    _last_transparent: bool = False
+    _transparent_pipeline = None
 
     def create_render_pipeline(self, options: RenderOptions) -> None:
         bindings = options.get_bindings() + self.get_bindings()
 
-        if bindings == self._last_bindings:
+        if bindings == self._last_bindings and self.transparent == self._last_transparent:
             return
 
-        shader_module = self.device.createShaderModule(self._get_preprocessed_shader_code())
         layout, self.group = create_bind_group(
             self.device, options.get_bindings() + self.get_bindings()
         )
         pipeline_layout = self.device.createPipelineLayout([layout])
-        vertex_state = VertexState(
-            module=shader_module,
-            entryPoint=self.vertex_entry_point,
-            buffers=self.vertex_buffer_layouts,
-        )
-        depth_stencil = DepthStencilState(
+
+        depth_stencil_opaque = DepthStencilState(
             format=options.canvas.depth_format,
             depthWriteEnabled=True,
             depthCompare=CompareFunction.less,
             depthBias=self.depthBias,
             depthBiasSlopeScale=self.depthBiasSlopeScale,
         )
-        self.pipeline = self.device.createRenderPipeline(
-            pipeline_layout,
-            vertex=vertex_state,
-            fragment=FragmentState(
+
+        if self.transparent:
+            opaque_shader = self.device.createShaderModule(
+                self._get_preprocessed_shader_code({"OPAQUE_PASS": "1"})
+            )
+            vertex_state = VertexState(
+                module=opaque_shader,
+                entryPoint=self.vertex_entry_point,
+                buffers=self.vertex_buffer_layouts,
+            )
+            self.pipeline = self.device.createRenderPipeline(
+                pipeline_layout,
+                vertex=vertex_state,
+                fragment=FragmentState(
+                    module=opaque_shader,
+                    entryPoint=self.fragment_entry_point,
+                    targets=[options.canvas.color_target],
+                ),
+                primitive=PrimitiveState(topology=self.topology),
+                depthStencil=depth_stencil_opaque,
+                multisample=options.canvas.multisample,
+                label=self.label + " (opaque)",
+            )
+
+            depth_stencil_transparent = DepthStencilState(
+                format=options.canvas.depth_format,
+                depthWriteEnabled=False,
+                depthCompare=CompareFunction.less,
+                depthBias=self.depthBias,
+                depthBiasSlopeScale=self.depthBiasSlopeScale,
+            )
+            transparent_shader = self.device.createShaderModule(
+                self._get_preprocessed_shader_code({"TRANSPARENT_PASS": "1"})
+            )
+            vertex_state_t = VertexState(
+                module=transparent_shader,
+                entryPoint=self.vertex_entry_point,
+                buffers=self.vertex_buffer_layouts,
+            )
+            self._transparent_pipeline = self.device.createRenderPipeline(
+                pipeline_layout,
+                vertex=vertex_state_t,
+                fragment=FragmentState(
+                    module=transparent_shader,
+                    entryPoint=self.fragment_entry_point,
+                    targets=[options.canvas.color_target],
+                ),
+                primitive=PrimitiveState(topology=self.topology),
+                depthStencil=depth_stencil_transparent,
+                multisample=options.canvas.multisample,
+                label=self.label + " (transparent)",
+            )
+        else:
+            shader_module = self.device.createShaderModule(self._get_preprocessed_shader_code())
+            vertex_state = VertexState(
                 module=shader_module,
-                entryPoint=self.fragment_entry_point,
-                targets=[options.canvas.color_target],
-            ),
-            primitive=PrimitiveState(topology=self.topology),
-            depthStencil=depth_stencil,
-            multisample=options.canvas.multisample,
-            label=self.label,
-        )
+                entryPoint=self.vertex_entry_point,
+                buffers=self.vertex_buffer_layouts,
+            )
+            self.pipeline = self.device.createRenderPipeline(
+                pipeline_layout,
+                vertex=vertex_state,
+                fragment=FragmentState(
+                    module=shader_module,
+                    entryPoint=self.fragment_entry_point,
+                    targets=[options.canvas.color_target],
+                ),
+                primitive=PrimitiveState(topology=self.topology),
+                depthStencil=depth_stencil_opaque,
+                multisample=options.canvas.multisample,
+                label=self.label,
+            )
+            self._transparent_pipeline = None
 
         if self.select_entry_point:
             select_shader_module = self.device.createShaderModule(
                 self._get_preprocessed_shader_code({"SELECT_PIPELINE": "1"})
             )
-            vertex_state.module = select_shader_module
+            vertex_state_s = VertexState(
+                module=select_shader_module,
+                entryPoint=self.vertex_entry_point,
+                buffers=self.vertex_buffer_layouts,
+            )
             self._select_pipeline = self.device.createRenderPipeline(
                 pipeline_layout,
-                vertex=vertex_state,
+                vertex=vertex_state_s,
                 fragment=FragmentState(
                     module=select_shader_module,
                     entryPoint=self.select_entry_point,
                     targets=[options.canvas.select_target],
                 ),
                 primitive=PrimitiveState(topology=self.topology),
-                depthStencil=depth_stencil,
+                depthStencil=depth_stencil_opaque,
                 multisample=MultisampleState(),
                 label=self.label + " (select)",
             )
@@ -382,6 +467,7 @@ class Renderer(BaseRenderer):
             self._select_pipeline = None
 
         self._last_bindings = bindings
+        self._last_transparent = self.transparent
 
     def render(self, options: RenderOptions) -> None:
         render_pass = options.begin_render_pass()
@@ -392,6 +478,17 @@ class Renderer(BaseRenderer):
         render_pass.draw(self.n_vertices, self.n_instances)
         render_pass.end()
 
+    def render_opaque(self, options: RenderOptions) -> None:
+        self.render(options)
+
+    def render_transparent(self, options: RenderOptions) -> None:
+        if not self._transparent_pipeline:
+            return
+        saved = self.pipeline
+        self.pipeline = self._transparent_pipeline
+        self.render(options)
+        self.pipeline = saved
+
     def select(self, options: RenderOptions, x: int, y: int) -> None:
         if not self._select_pipeline:
             return

webgpu/scene.py

@@ -123,11 +123,18 @@ class Scene:
 
     def __on_update_html_canvas(self, html_canvas):
         """Update event wiring when the underlying HTML canvas element changes."""
-        self.input_handler.set_canvas(html_canvas)
+        camera = self.options.camera
         if html_canvas is not None:
-            camera = self.options.camera
+            self.input_handler.set_canvas(html_canvas)
             camera.set_render_functions(self.render, self.get_position)
+            camera.register_callbacks(self.input_handler)
             camera.set_canvas(self.canvas)
+        else:
+            camera.unregister_callbacks(self.input_handler)
+            if camera._render_function == self.render:
+                camera._render_function = None
+                camera._get_position_function = None
+            self.input_handler.set_canvas(None)
 
     def get_position(self, x: int, y: int):
         """Return the 3D position under canvas pixel (x, y) using the selection buffer."""
@@ -226,22 +233,27 @@ class Scene:
             return ev
 
     # @print_communications
-    def _render_objects(self, to_canvas=True):
+    def _render_objects(self, to_canvas=True, update_pipelines=True):
         """Update pipelines and render all active objects, optionally copying to the canvas."""
         if self.canvas is None:
             return
-        self._select_buffer_valid = False
         options = self.options
-        for obj in self.render_objects:
-            if obj.active:
-                obj._update_and_create_render_pipeline(options)
-                if obj.needs_update:
-                    print("warning: object still needs update after update was done:", obj)
+
+        if update_pipelines:
+            self._select_buffer_valid = False
+            for obj in self.render_objects:
+                if obj.active:
+                    obj._update_and_create_render_pipeline(options)
+                    if obj.needs_update:
+                        print("warning: object still needs update after update was done:", obj)
 
         options.command_encoder = self.device.createCommandEncoder()
         for obj in self.render_objects:
             if obj.active:
-                obj.render(options)
+                obj.render_opaque(options)
+        for obj in self.render_objects:
+            if obj.active:
+                obj.render_transparent(options)
 
         if to_canvas:
                 target_texture = self.canvas.target_texture
@@ -266,6 +278,21 @@ class Scene:
         self.device.queue.submit([options.command_encoder.finish()])
         options.command_encoder = None
 
+    def _render_highlight(self):
+        """Fast re-render for highlight-only uniform changes.
+
+        Skips pipeline rebuild and select buffer invalidation.
+        Caller must already hold _render_mutex.
+        """
+        if self.canvas is None or self.canvas.height == 0:
+            return
+        self._render_objects(to_canvas=False, update_pipelines=False)
+        platform.js.patchedRequestAnimationFrame(
+            self.canvas.device.handle,
+            self.canvas.context,
+            self.canvas.target_texture,
+        )
+
     def redraw(self, blocking=False, fps=10):
         """Request a redraw, either blocking immediately or debounced on the event loop."""
         self.options.timestamp = time.time()

webgpu/shaders/gizmo_edges.wgsl

@@ -0,0 +1,61 @@
+#import camera
+
+@group(0) @binding(90) var<storage> u_edges: array<f32>;
+
+struct GizmoUniforms {
+    corner: vec2f,
+    scale: f32,
+    thickness: f32,
+};
+@group(0) @binding(93) var<uniform> u_gizmo: GizmoUniforms;
+
+struct VertexOutput {
+    @builtin(position) position: vec4f,
+};
+
+@vertex
+fn vertex_main(@builtin(vertex_index) vertId: u32,
+               @builtin(instance_index) edgeId: u32) -> VertexOutput {
+    var out: VertexOutput;
+
+    let p1_3d = vec3f(u_edges[edgeId * 6u], u_edges[edgeId * 6u + 1u], u_edges[edgeId * 6u + 2u]);
+    let p2_3d = vec3f(u_edges[edgeId * 6u + 3u], u_edges[edgeId * 6u + 4u], u_edges[edgeId * 6u + 5u]);
+
+    let r1 = (u_camera.rot_mat * vec4f(p1_3d, 0.0)).xyz;
+    let r2 = (u_camera.rot_mat * vec4f(p2_3d, 0.0)).xyz;
+
+    var off1 = r1.xy * u_gizmo.scale;
+    var off2 = r2.xy * u_gizmo.scale;
+    off1.x /= u_camera.aspect;
+    off2.x /= u_camera.aspect;
+    let sp1 = u_gizmo.corner + off1;
+    let sp2 = u_gizmo.corner + off2;
+
+    let v = normalize(sp2 - sp1);
+    var normal = vec2f(-v.y, v.x) * u_gizmo.thickness;
+
+    var pos: vec2f;
+    var z: f32;
+    if (vertId == 0u) {
+        pos = sp1 - normal;
+        z = r1.z;
+    } else if (vertId == 1u) {
+        pos = sp1 + normal;
+        z = r1.z;
+    } else if (vertId == 2u) {
+        pos = sp2 - normal;
+        z = r2.z;
+    } else {
+        pos = sp2 + normal;
+        z = r2.z;
+    }
+
+    let depth = 0.01 - z * 0.015;
+    out.position = vec4f(pos, depth, 1.0);
+    return out;
+}
+
+@fragment
+fn fragment_main(input: VertexOutput) -> @location(0) vec4f {
+    return vec4f(0.15, 0.15, 0.15, 1.0);
+}

webgpu/shaders/gizmo_mesh.wgsl

@@ -0,0 +1,62 @@
+#import camera
+
+@group(0) @binding(90) var<storage> u_positions: array<f32>;
+@group(0) @binding(91) var<storage> u_normals: array<f32>;
+@group(0) @binding(92) var<storage> u_colors: array<f32>;
+
+struct GizmoUniforms {
+    corner: vec2f,
+    scale: f32,
+    padding: f32,
+};
+@group(0) @binding(93) var<uniform> u_gizmo: GizmoUniforms;
+
+struct VertexOutput {
+    @builtin(position) position: vec4f,
+    @location(0) color: vec4f,
+    @location(1) @interpolate(flat) face_index: u32,
+};
+
+@vertex
+fn vertex_main(@builtin(vertex_index) vid: u32) -> VertexOutput {
+    var out: VertexOutput;
+
+    let pos = vec3f(u_positions[vid * 3u], u_positions[vid * 3u + 1u], u_positions[vid * 3u + 2u]);
+    let normal = vec3f(u_normals[vid * 3u], u_normals[vid * 3u + 1u], u_normals[vid * 3u + 2u]);
+    let color = vec4f(u_colors[vid * 4u], u_colors[vid * 4u + 1u], u_colors[vid * 4u + 2u], u_colors[vid * 4u + 3u]);
+
+    let rotated = (u_camera.rot_mat * vec4f(pos, 0.0)).xyz;
+    let rot_normal = normalize((u_camera.rot_mat * vec4f(normal, 0.0)).xyz);
+
+    // Simple directional lighting
+    let light_dir = normalize(vec3f(0.4, 0.7, 1.0));
+    let ambient = 0.35;
+    let diffuse = max(dot(rot_normal, light_dir), 0.0) * 0.55;
+    let back_diffuse = max(dot(-rot_normal, light_dir), 0.0) * 0.2;
+    let brightness = ambient + diffuse + back_diffuse;
+
+    // Aspect-correct positioning: only scale the gizmo part, not the corner
+    var gizmo_offset = rotated.xy * u_gizmo.scale;
+    gizmo_offset.x /= u_camera.aspect;
+    let ndc = u_gizmo.corner + gizmo_offset;
+
+    // Depth: near 0 so gizmo is always in front, but spread for self-occlusion
+    let depth = 0.02 - rotated.z * 0.015;
+
+    out.position = vec4f(ndc, depth, 1.0);
+    out.color = vec4f(color.rgb * brightness, color.a);
+    out.face_index = vid / 6u;
+    return out;
+}
+
+@fragment
+fn fragment_main(input: VertexOutput) -> @location(0) vec4f {
+    return vec4f(input.color.rgb * input.color.a, input.color.a);
+}
+
+#ifdef SELECT_PIPELINE
+@fragment
+fn fragment_select(input: VertexOutput) -> @location(0) vec4<u32> {
+    return vec4<u32>(@RENDER_OBJECT_ID@, bitcast<u32>(input.position.z), 0u, input.face_index);
+}
+#endif SELECT_PIPELINE