fix 0 division of meshscatter normals (#5478)

* fix 0 scale normals

* update changelog

* tweak refimg

* fix format

Author: ffreyer

CHANGELOG.md

@@ -5,8 +5,9 @@
 - Added loading spinner in WGLMakie that displays while the plot is being loaded [#5469](https://github.com/MakieOrg/Makie.jl/pull/5469)
 - Moved decoration plots in `Axis3` to `ax.blockscene` so they no longer show up as user plots in the Axis3 [#5463](https://github.com/MakieOrg/Makie.jl/pull/5463)
 - Fixed issue with `transformation` being applied multiple times when set by a user in a recipe that passes applicable attributes to child plots [#5464](https://github.com/MakieOrg/Makie.jl/pull/5464)
-- Fix `arrows2d[!]` plot elements causing CairoMakie SVGs to be rasterized. [#5459](https://github.com/MakieOrg/Makie.jl/pull/#5459)
-- Fix plotting order of multi-arrow `arrows2d[!]` to respect z-coordinates. [#5459](https://github.com/MakieOrg/Makie.jl/pull/#5459)
+- Fixed `arrows2d[!]` plot elements causing CairoMakie SVGs to be rasterized. [#5459](https://github.com/MakieOrg/Makie.jl/pull/#5459)
+- Fixed plotting order of multi-arrow `arrows2d[!]` to respect z-coordinates. [#5459](https://github.com/MakieOrg/Makie.jl/pull/#5459)
+- Fixed `meshscatter` objects rendering with incorrect color when scaled to 0 [#5478](https://github.com/MakieOrg/Makie.jl/pull/5478)
 
 ## [0.24.8] - 2025-12-04
 

CairoMakie/src/mesh.jl

@@ -404,8 +404,10 @@ function draw_scattered_mesh(
         element_uv_transform = Makie.sv_getindex(uv_transform, i)
         element_translation = to_ndim(Point4d, positions[i], 0)
         element_rotation = Makie.rotationmatrix4(Makie.sv_getindex(rotations, i))
-        element_scale = Makie.scalematrix(Makie.sv_getindex(scales, i))
-        element_transform = element_rotation * element_scale # different order from transformationmatrix()
+        element_scale = Makie.sv_getindex(scales, i)
+        element_scale_matrix = Makie.scalematrix(element_scale)
+        # different order from transformationmatrix()
+        element_transform = f32c_model * element_rotation * element_scale_matrix
 
         # Note: These are not part of the compute graph because the number of
         # vertices of the mesh * number of positions in meshscatter could become
@@ -418,16 +420,20 @@ function draw_scattered_mesh(
         # =        f32c_model          * element_transform * vertices  +       element_translation
         element_world_pos = map(meshpoints) do p
             p4d = to_ndim(Point4d, to_ndim(Point3d, p, 0), 1)
-            p4d = f32c_model * element_transform * p4d + element_translation
+            p4d = element_transform * p4d + element_translation
             return Point3f(p4d) / p4d[4]
         end
 
         element_screen_pos = project_position(Point3f, proj_mat, element_world_pos, eachindex(element_world_pos))
 
+        # only used for normals
+        finite_element_scale = @. ifelse(element_scale >= 0, +1, -1) * max(abs(element_scale), 1.0e-6)
+        model = f32c_model * element_rotation * Makie.scalematrix(finite_element_scale)
+
         draw_mesh3D(
             scene, screen, plot,
             element_world_pos, element_screen_pos, meshfaces, meshnormals, meshuvs,
-            element_uv_transform, element_color, clip_planes, f32c_model * element_transform
+            element_uv_transform, element_color, clip_planes, model
         )
     end
 

GLMakie/assets/shader/particles.vert

@@ -116,13 +116,30 @@ vec3 get_uv(int index, vec3 uv) {
     return uv;
 }
 
+vec3 finite_sign(vec3 v)
+{
+    return vec3(
+        2 * float(v[0] >= 0) - 1,
+        2 * float(v[1] >= 0) - 1,
+        2 * float(v[2] >= 0) - 1
+    );
+}
+
+vec3 finite_div(vec3 v, vec3 d)
+{
+    // sign(0) = 0
+    vec3 df = finite_sign(d) * max(abs(d), 0.0000001);
+    return v / df;
+}
 
 void main(){
     int index = gl_InstanceID;
     o_id = uvec2(objectid, index+1);
     vec3 s = _scale(scale, index);
     vec3 V = s * vertices;
-    vec3 N = normals / s; // see issue #3702
+    // needed if scale distorts the shape, see issue #3702
+    // can't allow zero division, see #5477
+    vec3 N = finite_div(normals, s);
     vec3 pos;
     {{position_calc}}
     o_color = get_particle_color(color, intensity, color_map, color_norm, index, len);

ReferenceTests/src/tests/examples3d.jl

@@ -201,16 +201,25 @@ end
 end
 
 @reference_test "Basic Shading" begin
-    f = Figure(size = (500, 300))
+    f = Figure(size = (500, 500))
 
     # see PR #3722
     pts = Point3f[[0, 0, 0], [1, 0, 0]]
     markersize = Vec3f[[0.5, 0.2, 0.5], [0.5, 0.2, 0.5]]
     rotation = [qrotation(Vec3f(1, 0, 0), 0), qrotation(Vec3f(1, 1, 0), π / 4)]
-    meshscatter(f[1, 1], pts; markersize, rotation, color = :white, diffuse = Vec3f(-2, 0, 4), specular = Vec3f(4, 0, -2))
+    meshscatter(
+        f[1, 1], pts; markersize, rotation, color = :white,
+        diffuse = Vec3f(-2, 0, 4), specular = Vec3f(4, 0, -2)
+    )
 
     mesh(f[1, 2], Sphere(Point3f(0), 1.0f0), color = :orange, shading = NoShading)
 
+    markersize = Vec3f[[0.5, 0.0, 0.5], [0.5, 0.2, 0.0]]
+    meshscatter(
+        f[2, 1], pts; markersize, rotation, color = :white,
+        diffuse = Vec3f(-2, 0, 4), specular = Vec3f(4, 0, -2), backlight = 1
+    )
+
     f
 end
 

WGLMakie/assets/particles.vert

@@ -75,11 +75,29 @@ vec4 to_color(vec4 c) {
     return c;
 }
 
+vec3 finite_sign(vec3 v)
+{
+    return vec3(
+        2.0 * float(v[0] >= 0.0) - 1.0,
+        2.0 * float(v[1] >= 0.0) - 1.0,
+        2.0 * float(v[2] >= 0.0) - 1.0
+    );
+}
+
+vec3 finite_div(vec3 v, vec3 d)
+{
+    // sign(0) = 0
+    vec3 df = finite_sign(d) * max(abs(d), 0.0000001);
+    return v / df;
+}
+
 void main(){
     // get_* gets the global inputs (uniform, sampler, position array)
     // those functions will get inserted by the shader creation pipeline
     vec3 vertex_position = get_markersize() * to_vec3(get_vertex_position());
-    vec3 N = get_normal() / get_markersize(); // see issue #3702
+    // needed for uneven scales, see issue #3702
+    // can't divide by zero though
+    vec3 N = finite_div(get_normal(), get_markersize());
     rotate(get_converted_rotation(), vertex_position, N);
     vertex_position = get_f32c_scale() * vertex_position;
     N = N / get_f32c_scale();