Fix register_positions_projected! not updating when float32convert changes

When projecting from a non-data space (e.g. :relative, :pixel) to a data
space, the camera matrices give f32c-scaled coordinates because the camera
projection is set up in f32c space. To get actual data coordinates, we
need to apply the inverse of float32convert to the output positions.

This fix:
- Detects when we're projecting from non-data space to data space
- Adds :f32c as a dependency so output updates when float32convert changes
- Applies inv(f32c) to convert f32c-scaled coordinates to data coordinates

Note: This does not yet handle transform_func for these projections.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: asinghvi17

Makie/src/utilities/projection_utils.jl

@@ -147,7 +147,15 @@ function register_positions_projected!(
 
     # apply projection
     # clip planes only apply from data/world space.
-    if apply_clip_planes && (is_data_space(input_space) || input_space === :space)
+
+    # When projecting from a non-data space (e.g. :relative, :pixel) to data space,
+    # we need to apply the inverse of float32convert. The camera matrices operate
+    # in f32c-scaled space, so to get actual data coordinates we must undo the scaling.
+    input_is_data_space = is_data_space(input_space) || input_space === :space
+    output_is_data_space = is_data_space(output_space) || output_space === :space
+    needs_inv_f32c = output_is_data_space && !input_is_data_space
+
+    if apply_clip_planes && input_is_data_space
         # easiest to transform them to the space of the projection input and
         # clip based on those points
         if apply_model
@@ -167,8 +175,24 @@ function register_positions_projected!(
             end
         end
 
+    elseif needs_inv_f32c
+        # Projecting from non-data space to data space: apply inverse f32c.
+        # f32c in the compute graph is a LinearScaling, which is callable.
+        # inv(f32c) returns the inverse LinearScaling that we broadcast over positions.
+        if output_space === :space # dynamic output space
+            map!(plot_graph, [merged_matrix_name, input_name, :f32c, :space], output_name) do matrix, pos, f32c, space
+                projected = _project(OT, matrix, pos)
+                return is_data_space(space) ? inv(f32c).(projected) : projected
+            end
+        else # static output space (:data)
+            map!(plot_graph, [merged_matrix_name, input_name, :f32c], output_name) do matrix, pos, f32c
+                projected = _project(OT, matrix, pos)
+                return inv(f32c).(projected)
+            end
+        end
+
     else
-        # no clip planes, just project everything
+        # no clip planes, no inv_f32c needed, just project everything
         map!(plot_graph, [merged_matrix_name, input_name], output_name) do matrix, pos
             return _project(OT, matrix, pos)
         end

Makie/test/conversions/float32convert.jl

@@ -319,4 +319,64 @@ using Makie: Mat4f, Vec2d, Vec3d, Point2d, Point3d, Point4d
         end
     end
 
+    @testset "register_positions_projected! with float32convert changes" begin
+        # Test that projecting from relative space to data space correctly
+        # applies inverse float32convert and updates when f32c changes.
+        # This is important for features like pyramids that place markers
+        # at relative screen positions but need data-space coordinates.
+
+        f, a, p = lines(1:10 .* 1_000_000, 1:10 .* 1_000_000)
+
+        # Add input positions in relative space (0-1 range representing screen corners)
+        input_positions = [Point2f(0, 0), Point2f(1, 1)]
+        Makie.add_input!(p.attributes, :test_input_positions, input_positions)
+        Makie.register_positions_projected!(
+            p;
+            input_space = :relative,
+            output_space = :space,
+            input_name = :test_input_positions,
+            output_name = :test_dataspace_positions,
+        )
+        Makie.update_state_before_display!(f)
+
+        # Initially, float32convert should be identity (data range fits in Float32)
+        @test is_identity_transform(a.scene.float32convert)
+
+        # Get initial output positions - should map relative corners to data limits
+        initial_positions = p.test_dataspace_positions[]
+        initial_limits = a.finallimits[]
+
+        # Positions should approximately match the axis limits
+        # (relative (0,0) -> min of limits, relative (1,1) -> max of limits)
+        @test initial_positions[1][1] ≈ initial_limits.origin[1] rtol = 0.1
+        @test initial_positions[1][2] ≈ initial_limits.origin[2] rtol = 0.1
+        @test initial_positions[2][1] ≈ initial_limits.origin[1] + initial_limits.widths[1] rtol = 0.1
+        @test initial_positions[2][2] ≈ initial_limits.origin[2] + initial_limits.widths[2] rtol = 0.1
+
+        # Now zoom into a very small region to trigger float32convert
+        limits!(a, (500_000, 500_100), (500_000, 500_100))
+        Makie.update_state_before_display!(f)
+
+        # float32convert should now be non-identity due to precision requirements
+        @test !is_identity_transform(a.scene.float32convert)
+
+        # Get updated output positions
+        updated_positions = p.test_dataspace_positions[]
+        updated_limits = a.finallimits[]
+
+        # After zooming, the relative positions should now map to the new limits
+        # relative (0,0) -> new min, relative (1,1) -> new max
+        @test updated_positions[1][1] ≈ updated_limits.origin[1] rtol = 0.01
+        @test updated_positions[1][2] ≈ updated_limits.origin[2] rtol = 0.01
+        @test updated_positions[2][1] ≈ updated_limits.origin[1] + updated_limits.widths[1] rtol = 0.01
+        @test updated_positions[2][2] ≈ updated_limits.origin[2] + updated_limits.widths[2] rtol = 0.01
+
+        # The key test: positions should be in actual data coordinates, not f32c-scaled
+        # After zoom, updated_limits should be around (500_000, 500_000) to (500_100, 500_100)
+        @test 499_000 < updated_positions[1][1] < 501_000
+        @test 499_000 < updated_positions[1][2] < 501_000
+        @test 499_000 < updated_positions[2][1] < 501_000
+        @test 499_000 < updated_positions[2][2] < 501_000
+    end
+
 end