apply f32c.scale to meshscatter vertices in GLMakie, WGLMakie

GLMakie/assets/shader/particles.vert

@@ -63,6 +63,8 @@ vec3 _scale(samplerBuffer scale, int index);
 vec3 _scale(vec3          scale, int index);
 vec3 _scale(vec2          scale, int index);
 
+uniform vec3 f32c_scale;
+
 {{color_type}} color;
 {{color_map_type}} color_map;
 {{intensity_type}} intensity;
@@ -115,7 +117,7 @@ void main(){
     int index = gl_InstanceID;
     o_id = uvec2(objectid, index+1);
     vec3 s = _scale(scale, index);
-    vec3 V = vertices * s;
+    vec3 V = s * vertices;
     vec3 N = normals / s; // see issue #3702
     vec3 pos;
     {{position_calc}}
@@ -124,6 +126,8 @@ void main(){
     o_uv = get_uv(index, texturecoordinates);
     o_InstanceID = index;
     rotate(rotation, index, V, N);
+    V = f32c_scale * V;
+    N = N / f32c_scale;
     if (scale_primitive)
         render(model * vec4(pos + V, 1), N, view, projection);
     else

GLMakie/src/drawing_primitives.jl

@@ -467,6 +467,17 @@ function draw_atomic(screen::Screen, scene::Scene, @nospecialize(plot::Union{Sca
             return draw_pixel_scatter(screen, positions, gl_attributes)
         else
             if plot isa MeshScatter
+                # If the vertices of the scattered mesh, markersize and (if it applies) model
+                # are float32 safe we should be able to just correct for any scaling from
+                # float32convert in the shader, after those conversions.
+                # We should also be fine as long as rotation = identity (also in model).
+                # If neither is the case we would have to combine vertices with positions and
+                # transform them to world space (post float32convert) on the CPU. We then can't
+                # do instancing anymore, so meshscatter becomes pointless.
+                if !isnothing(scene.float32convert)
+                    gl_attributes[:f32c_scale] = map(x -> Vec3f(x.scale), plot, scene.float32convert.scaling)
+                end
+
                 if haskey(gl_attributes, :color) && to_value(gl_attributes[:color]) isa AbstractMatrix{<: Colorant}
                     gl_attributes[:image] = gl_attributes[:color]
                 end

GLMakie/src/glshaders/particles.jl

@@ -72,6 +72,7 @@ function draw_mesh_particle(screen, p, data)
         position = p[2] => TextureBuffer
         scale = Vec3f(1) => TextureBuffer
         rotation = rot => TextureBuffer
+        f32c_scale = Vec3f(1) # drawing_primitives.jl
         texturecoordinates = nothing
     end
 

WGLMakie/assets/particles.vert

@@ -89,14 +89,16 @@ void main(){
     vec3 vertex_position = get_markersize() * to_vec3(get_position());
     vec3 N = get_normals() / get_markersize(); // see issue #3702
     rotate(get_rotation(), vertex_position, N);
+    vertex_position = get_f32c_scale() * vertex_position;
+    N = N / get_f32c_scale();
     vec4 position_world;
     if (get_transform_marker())
         position_world = model * vec4(to_vec3(get_offset()) + vertex_position, 1);
     else
-        position_world = model * to_vec4(get_offset()) + vec4(vertex_position, 0);
+        position_world = model * to_vec4(to_vec3(get_offset())) + vec4(vertex_position, 0);
 
     process_clip_planes(position_world.xyz);
-    o_normal = N;
+    o_normal = normalize(N);
     frag_color = vertex_color(get_color(), get_colorrange(), colormap);
     frag_uv = apply_uv_transform(get_uv_transform(), get_uv());
     // direction to camera

WGLMakie/src/particles.jl

@@ -76,6 +76,13 @@ function create_shader(scene::Scene, plot::MeshScatter)
     uniform_dict[:interpolate_in_fragment_shader] = get(plot, :interpolate_in_fragment_shader, false)
     uniform_dict[:transform_marker] = get(plot, :transform_marker, false)
 
+    # See GLMakie/drawing_primtives.jl
+    if isnothing(f32c)
+        uniform_dict[:f32c_scale] = Vec3f(1)
+    else
+        uniform_dict[:f32c_scale] = map(x -> Vec3f(x.scale), plot, scene.float32convert.scaling)
+    end
+
     if haskey(uniform_dict, :color) && haskey(per_instance, :color)
         to_value(uniform_dict[:color]) isa Bool && delete!(uniform_dict, :color)
         to_value(per_instance[:color]) isa Bool && delete!(per_instance, :color)
@@ -84,6 +91,9 @@ function create_shader(scene::Scene, plot::MeshScatter)
     if !hasproperty(instance, :uv)
         uniform_dict[:uv] = Vec2f(0)
     end
+    if !hasproperty(instance, :normals)
+        uniform_dict[:normals] = Vec3f(0)
+    end
 
     uniform_dict[:depth_shift] = get(plot, :depth_shift, Observable(0f0))
     uniform_dict[:backlight] = plot.backlight