Honor point display geometry and sizing

src/shaders/block_wire.wgsl

@@ -26,6 +26,9 @@ struct WireConst {
     world_half_width: f32,
     _pad1: f32,
     _pad2: f32,
+    marker_origin_high: vec4<f32>,
+    marker_origin_low: vec4<f32>,
+    marker_normal_scale: vec4<f32>,
 }
 @group(1) @binding(0) var<uniform> wire_const: WireConst;
 
@@ -67,6 +70,29 @@ fn resolve_hw(taper_ratio: f32, world_hw: f32, px_hw: f32) -> f32 {
     return select(0.5, px_hw, u.lwdisplay_enable > 0.5);
 }
 
+fn marker_relative(
+    position_high: vec3<f32>,
+    position_low: vec3<f32>,
+    translation: vec3<f32>,
+    translation_low: vec3<f32>,
+) -> vec3<f32> {
+    if wire_const.marker_normal_scale.w <= 0.0 {
+        return (position_high + translation - u.eye_high)
+            + (position_low + translation_low - u.eye_low);
+    }
+    let origin_high = wire_const.marker_origin_high.xyz;
+    let origin_low = wire_const.marker_origin_low.xyz;
+    let origin_relative = (origin_high + translation - u.eye_high)
+        + (origin_low + translation_low - u.eye_low);
+    let delta = (position_high - origin_high) + (position_low - origin_low);
+    let normal = normalize(wire_const.marker_normal_scale.xyz);
+    let axial = normal * dot(delta, normal);
+    let planar = delta - axial;
+    let world_size = wire_const.marker_normal_scale.w * 0.01
+        * u.world_per_pixel * u.viewport_size.y;
+    return origin_relative + axial + planar * world_size;
+}
+
 @vertex
 fn vs_main(@builtin(vertex_index) vertex_index: u32, in: VertexIn) -> VertexOut {
     let corner = vertex_index % 6u;
@@ -75,10 +101,8 @@ fn vs_main(@builtin(vertex_index) vertex_index: u32, in: VertexIn) -> VertexOut
     let which_end = which_end_arr[corner];
     let side = side_arr[corner];
 
-    let rel_a = (in.pos_a + in.translation - u.eye_high)
-        + (in.pos_a_low + in.translation_low - u.eye_low);
-    let rel_b = (in.pos_b + in.translation - u.eye_high)
-        + (in.pos_b_low + in.translation_low - u.eye_low);
+    let rel_a = marker_relative(in.pos_a, in.pos_a_low, in.translation, in.translation_low);
+    let rel_b = marker_relative(in.pos_b, in.pos_b_low, in.translation, in.translation_low);
     let clip_a = u.view_rot * vec4<f32>(rel_a, 1.0);
     let clip_b = u.view_rot * vec4<f32>(rel_b, 1.0);
     let screen_a = clip_a.xy / clip_a.w * u.viewport_size * 0.5;

src/shaders/wire.wgsl

@@ -62,6 +62,9 @@ struct InstanceIn {
     @location(8) pos_b_low:      vec3<f32>,
     // Per-endpoint world half-width for a tapered band (0 = use the constant).
     @location(9) taper:          vec2<f32>,
+    @location(10) marker_origin_high: vec4<f32>,
+    @location(11) marker_origin_low: vec4<f32>,
+    @location(12) marker_normal_scale: vec4<f32>,
 }
 
 // Draw-order depth bias: shifts clip-space z so 2D entities of different
@@ -102,6 +105,21 @@ fn resolve_hw(taper: f32, world_hw: f32, px_hw: f32) -> f32 {
     return select(0.5, px_hw, u.lwdisplay_enable > 0.5);
 }
 
+fn marker_relative(position_high: vec3<f32>, position_low: vec3<f32>, instance: InstanceIn) -> vec3<f32> {
+    if instance.marker_normal_scale.w <= 0.0 {
+        return (position_high - u.eye_high) + (position_low - u.eye_low);
+    }
+    let origin_high = instance.marker_origin_high.xyz;
+    let origin_low = instance.marker_origin_low.xyz;
+    let origin_relative = (origin_high - u.eye_high) + (origin_low - u.eye_low);
+    let delta = (position_high - origin_high) + (position_low - origin_low);
+    let normal = normalize(instance.marker_normal_scale.xyz);
+    let axial = normal * dot(delta, normal);
+    let planar = delta - axial;
+    let world_size = instance.marker_normal_scale.w * 0.01 * u.world_per_pixel * u.viewport_size.y;
+    return origin_relative + axial + planar * world_size;
+}
+
 @vertex fn vs_main(@builtin(vertex_index) vid: u32, in: InstanceIn) -> VertexOut {
     // Two-triangle quad corner table:
     //   vid 0,1,2 = (A,-1) (B,-1) (B,+1)
@@ -117,8 +135,8 @@ fn resolve_hw(taper: f32, world_hw: f32, px_hw: f32) -> f32 {
     // operands (Sterbenz); adding (pos_low − eye_low) restores the residual both
     // the vertex and the eye would otherwise lose — so geometry stays put at
     // UTM-scale coordinates and after a cross-drawing paste, with no jitter.
-    let rel_a = (in.pos_a - u.eye_high) + (in.pos_a_low - u.eye_low);
-    let rel_b = (in.pos_b - u.eye_high) + (in.pos_b_low - u.eye_low);
+    let rel_a = marker_relative(in.pos_a, in.pos_a_low, in);
+    let rel_b = marker_relative(in.pos_b, in.pos_b_low, in);
     let clip_a = u.view_rot * vec4<f32>(rel_a, 1.0);
     let clip_b = u.view_rot * vec4<f32>(rel_b, 1.0);
 

src/shaders/wire_indexed.wgsl

@@ -34,6 +34,9 @@ struct WireConst {
     world_half_width: f32,
     _pad1:          f32,
     _pad2:          f32,
+    marker_origin_high: vec4<f32>,
+    marker_origin_low: vec4<f32>,
+    marker_normal_scale: vec4<f32>,
 }
 @group(1) @binding(0) var<storage, read> wire_consts: array<WireConst>;
 
@@ -81,6 +84,21 @@ fn resolve_hw(taper_ratio: f32, world_hw: f32, px_hw: f32) -> f32 {
     return select(0.5, px_hw, u.lwdisplay_enable > 0.5);
 }
 
+fn marker_relative(position_high: vec3<f32>, position_low: vec3<f32>, c: WireConst) -> vec3<f32> {
+    if c.marker_normal_scale.w <= 0.0 {
+        return (position_high - u.eye_high) + (position_low - u.eye_low);
+    }
+    let origin_high = c.marker_origin_high.xyz;
+    let origin_low = c.marker_origin_low.xyz;
+    let origin_relative = (origin_high - u.eye_high) + (origin_low - u.eye_low);
+    let delta = (position_high - origin_high) + (position_low - origin_low);
+    let normal = normalize(c.marker_normal_scale.xyz);
+    let axial = normal * dot(delta, normal);
+    let planar = delta - axial;
+    let world_size = c.marker_normal_scale.w * 0.01 * u.world_per_pixel * u.viewport_size.y;
+    return origin_relative + axial + planar * world_size;
+}
+
 @vertex fn vs_main(@builtin(vertex_index) vid: u32, in: InstanceIn) -> VertexOut {
     let c = wire_consts[in.wire_id];
 
@@ -89,8 +107,8 @@ fn resolve_hw(taper_ratio: f32, world_hw: f32, px_hw: f32) -> f32 {
     let which_end = which_end_arr[vid];
     let side      = side_arr[vid];
 
-    let rel_a = (in.pos_a - u.eye_high) + (in.pos_a_low - u.eye_low);
-    let rel_b = (in.pos_b - u.eye_high) + (in.pos_b_low - u.eye_low);
+    let rel_a = marker_relative(in.pos_a, in.pos_a_low, c);
+    let rel_b = marker_relative(in.pos_b, in.pos_b_low, c);
     let clip_a = u.view_rot * vec4<f32>(rel_a, 1.0);
     let clip_b = u.view_rot * vec4<f32>(rel_b, 1.0);