Beta 0.20

.github/workflows/glmakie.yaml

@@ -44,7 +44,7 @@ jobs:
           version: ${{ matrix.version }}
           arch: ${{ matrix.arch }}
       - uses: julia-actions/cache@v1
-      - run: sudo apt-get update && sudo apt-get install -y xorg-dev mesa-utils xvfb libgl1 freeglut3-dev libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libxext-dev
+      - run: sudo apt-get update && sudo apt-get install -y xorg-dev mesa-utils xvfb libgl1 freeglut3-dev libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libxext-dev xsettingsd x11-xserver-utils
       - name: Install Julia dependencies
         shell: julia --project=monorepo {0}
         run: |

CairoMakie/Project.toml

@@ -1,7 +1,7 @@
 name = "CairoMakie"
 uuid = "13f3f980-e62b-5c42-98c6-ff1f3baf88f0"
 author = ["Simon Danisch <[email protected]>"]
-version = "0.10.7"
+version = "0.11.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -23,7 +23,7 @@ FFTW = "1"
 FileIO = "1.1"
 FreeType = "3, 4.0"
 GeometryBasics = "0.4.1"
-Makie = "=0.19.7"
+Makie = "=0.20.0"
 PrecompileTools = "1.0"
 julia = "1.3"
 
@@ -33,3 +33,4 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
 test = ["Test", "Pkg"]
+

CairoMakie/src/display.jl

@@ -117,6 +117,7 @@ end
 
 const DISABLED_MIMES = Set{String}()
 const SUPPORTED_MIMES = Set([
+    map(x->string(x()), Makie.WEB_MIMES)...,
     "image/svg+xml",
     "application/pdf",
     "application/postscript",

CairoMakie/src/primitives.jl

@@ -747,8 +747,16 @@ function draw_mesh2D(scene, screen, per_face_cols, space::Symbol, transform_func
     # This is a hack, which needs cleaning up in the Mesh plot type!
 
     for (f, (c1, c2, c3)) in zip(fs, per_face_cols)
-        pattern = Cairo.CairoPatternMesh()
+
         t1, t2, t3 =  project_position.(scene, (transform_func,), space, vs[f], (model,)) #triangle points
+
+        # don't draw any mesh faces with NaN components.
+        if isnan(t1) || isnan(t2) || isnan(t3)
+            continue
+        end
+
+        pattern = Cairo.CairoPatternMesh()
+
         Cairo.mesh_pattern_begin_patch(pattern)
 
         Cairo.mesh_pattern_move_to(pattern, t1...)
@@ -784,7 +792,7 @@ function draw_mesh3D(scene, screen, attributes, mesh; pos = Vec4f(0), scale = 1f
 
     meshpoints = decompose(Point3f, mesh)::Vector{Point3f}
     meshfaces = decompose(GLTriangleFace, mesh)::Vector{GLTriangleFace}
-    meshnormals = decompose_normals(mesh)::Vector{Vec3f}
+    meshnormals = decompose_normals(mesh)::Vector{Vec3f} # note: can be made NaN-aware.
     meshuvs = texturecoordinates(mesh)::Union{Nothing, Vector{Vec2f}}
 
     color = hasproperty(mesh, :color) ? mesh.color : to_value(attributes.calculated_colors)
@@ -828,7 +836,8 @@ function draw_mesh3D(
     end
 
     ns = map(n -> normalize(normalmatrix * n), meshnormals)
-    # Liight math happens in view/camera space
+
+    # Light math happens in view/camera space
     pointlight = Makie.get_point_light(scene)
     lightposition = if !isnothing(pointlight)
         pointlight.position[]
@@ -883,13 +892,17 @@ end
 
 function draw_pattern(ctx, zorder, shading, meshfaces, ts, per_face_col, ns, vs, lightpos, shininess, diffuse, ambient, specular)
     for k in reverse(zorder)
-        pattern = Cairo.CairoPatternMesh()
 
         f = meshfaces[k]
         # avoid SizedVector through Face indexing
         t1 = ts[f[1]]
         t2 = ts[f[2]]
         t3 = ts[f[3]]
+
+        # skip any mesh segments with NaN points.
+        if isnan(t1) || isnan(t2) || isnan(t3)
+            continue
+        end
 
         facecolors = per_face_col[k]
         # light calculation
@@ -911,6 +924,8 @@ function draw_pattern(ctx, zorder, shading, meshfaces, ts, per_face_col, ns, vs,
         # c1 = RGB(n1...)
         # c2 = RGB(n2...)
         # c3 = RGB(n3...)
+
+        pattern = Cairo.CairoPatternMesh()
 
         Cairo.mesh_pattern_begin_patch(pattern)
 
@@ -938,7 +953,7 @@ end
 
 function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Makie.Surface))
     # Pretend the surface plot is a mesh plot and plot that instead
-    mesh = surface2mesh(primitive[1][], primitive[2][], primitive[3][])
+    mesh = Makie.surface2mesh(primitive[1][], primitive[2][], primitive[3][])
     old = primitive[:color]
     if old[] === nothing
         primitive[:color] = primitive[3]
@@ -951,14 +966,6 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Maki
     return nothing
 end
 
-function surface2mesh(xs, ys, zs::AbstractMatrix)
-    ps = Makie.matrix_grid(p-> nan2zero.(p), xs, ys, zs)
-    rect = Tesselation(Rect2f(0, 0, 1, 1), size(zs))
-    faces = decompose(QuadFace{Int}, rect)
-    uv = map(x-> Vec2f(1f0 - x[2], 1f0 - x[1]), decompose_uv(rect))
-    uvm = GeometryBasics.Mesh(GeometryBasics.meta(ps; uv=uv), faces)
-    return GeometryBasics.normal_mesh(uvm)
-end
 
 ################################################################################
 #                                 MeshScatter                                  #

CairoMakie/src/screen.jl

@@ -1,6 +1,6 @@
 using Base.Docs: doc
 
-@enum RenderType SVG IMAGE PDF EPS
+@enum RenderType SVG IMAGE PDF EPS HTML
 
 Base.convert(::Type{RenderType}, ::MIME{SYM}) where SYM = mime_to_rendertype(SYM)
 function Base.convert(::Type{RenderType}, type::String)
@@ -12,6 +12,8 @@ function Base.convert(::Type{RenderType}, type::String)
         return PDF
     elseif type == "eps"
         return EPS
+    elseif type in ("html", "text/html", "application/vnd.webio.application+html", "application/prs.juno.plotpane+html", "juliavscode/html")
+        return HTML
     else
         error("Unsupported cairo render type: $type")
     end
@@ -22,6 +24,7 @@ function to_mime(type::RenderType)
     type == SVG && return MIME("image/svg+xml")
     type == PDF && return MIME("application/pdf")
     type == EPS && return MIME("application/postscript")
+    type == HTML && return MIME("text/html")
     return MIME("image/png")
 end
 
@@ -35,6 +38,8 @@ function mime_to_rendertype(mime::Symbol)::RenderType
         return PDF
     elseif mime == Symbol("application/postscript")
         return EPS
+    elseif mime in (Symbol("text/html"), Symbol("text/html"), Symbol("application/vnd.webio.application+html"), Symbol("application/prs.juno.plotpane+html"), Symbol("juliavscode/html"))
+        return HTML
     else
         error("Unsupported mime: $mime")
     end
@@ -55,7 +60,7 @@ function surface_from_output_type(type::RenderType, io, w, h)
         return Cairo.CairoPDFSurface(io, w, h)
     elseif type === EPS
         return Cairo.CairoEPSSurface(io, w, h)
-    elseif type === IMAGE
+    elseif type === IMAGE || type === HTML
         img = fill(ARGB32(0, 0, 0, 0), w, h)
         return Cairo.CairoImageSurface(img)
     else
@@ -76,8 +81,8 @@ end
 to_cairo_antialias(aa::Int) = aa
 
 """
-* `px_per_unit = 1.0`: see [figure size docs](https://docs.makie.org/stable/documentation/figure_size/).
-* `pt_per_unit = 0.75`: see [figure size docs](https://docs.makie.org/stable/documentation/figure_size/).
+* `px_per_unit = 2.0`: see [figure docs](https://docs.makie.org/stable/documentation/figure_size/).
+* `pt_per_unit = 0.75`: see [figure docs](https://docs.makie.org/stable/documentation/figure_size/).
 * `antialias::Union{Symbol, Int} = :best`: antialias modus Cairo uses to draw. Applicable options: `[:best => Cairo.ANTIALIAS_BEST, :good => Cairo.ANTIALIAS_GOOD, :subpixel => Cairo.ANTIALIAS_SUBPIXEL, :none => Cairo.ANTIALIAS_NONE]`.
 * `visible::Bool`: if true, a browser/image viewer will open to display rendered output.
 """
@@ -120,9 +125,7 @@ function activate!(; inline=LAST_INLINE[], type="png", screen_config...)
         # So, if we want to prefer the png mime, we disable the mimes that are usually higher up in the stack.
         disable_mime!("svg", "pdf")
     elseif type == "svg"
-        # SVG is usually pretty high up the priority, so we can just enable all mimes
-        # If we implement html display for CairoMakie, we might need to disable that.
-        disable_mime!()
+        disable_mime!("text/html", "application/vnd.webio.application+html", "application/prs.juno.plotpane+html", "juliavscode/html")
     else
         enable_only_mime!(type)
     end

CairoMakie/src/utils.jl

@@ -118,6 +118,15 @@ end
 
 to_uint32_color(c) = reinterpret(UInt32, convert(ARGB32, premultiplied_rgba(c)))
 
+# handle patterns
+function Cairo.CairoPattern(color::Makie.AbstractPattern)
+    # the Cairo y-coordinate are fliped
+    bitmappattern = reverse!(ARGB32.(Makie.to_image(color)); dims=2)
+    cairoimage = Cairo.CairoImageSurface(bitmappattern)
+    cairopattern = Cairo.CairoPattern(cairoimage)
+    return cairopattern
+end
+
 ########################################
 #        Common color utilities        #
 ########################################
@@ -231,14 +240,10 @@ function mesh_pattern_set_corner_color(pattern, id, c::Colorant)
     Cairo.mesh_pattern_set_corner_color_rgba(pattern, id, rgbatuple(c)...)
 end
 
-# not piracy
-function Cairo.CairoPattern(color::Makie.AbstractPattern)
-    # the Cairo y-coordinate are fliped
-    bitmappattern = reverse!(ARGB32.(Makie.to_image(color)); dims=2)
-    cairoimage = Cairo.CairoImageSurface(bitmappattern)
-    cairopattern = Cairo.CairoPattern(cairoimage)
-    return cairopattern
-end
+################################################################################
+#                                Font handling                                 #
+################################################################################
+
 
 """
 Finds a font that can represent the unicode character!

CairoMakie/test/runtests.jl

@@ -64,7 +64,7 @@ include(joinpath(@__DIR__, "rasterization_tests.jl"))
         fig = scatter(1:4, figure=(; resolution=(800, 800)))
         save("test.pdf", fig)
         save("test.png", fig)
-        @test size(load("test.png")) == (800, 800)
+        @test size(load("test.png")) == (1600, 1600)
         rm("test.pdf")
         rm("test.png")
     end
@@ -193,7 +193,7 @@ excludes = Set([
 functions = [:volume, :volume!, :uv_mesh]
 
 @testset "refimages" begin
-    CairoMakie.activate!(type = "png")
+    CairoMakie.activate!(type = "png", px_per_unit = 1)
     ReferenceTests.mark_broken_tests(excludes, functions=functions)
     recorded_files, recording_dir = @include_reference_tests "refimages.jl"
     missing_images, scores = ReferenceTests.record_comparison(recording_dir)

GLMakie/Project.toml

@@ -1,6 +1,6 @@
 name = "GLMakie"
 uuid = "e9467ef8-e4e7-5192-8a1a-b1aee30e663a"
-version = "0.8.7"
+version = "0.9.0"
 
 [deps]
 ColorTypes = "3da002f7-5984-5a60-b8a6-cbb66c0b333f"
@@ -27,9 +27,9 @@ Colors = "0.11, 0.12"
 FileIO = "1.6"
 FixedPointNumbers = "0.7, 0.8"
 FreeTypeAbstraction = "0.10"
-GLFW = "3"
+GLFW = "3.3"
 GeometryBasics = "0.4.1"
-Makie = "=0.19.7"
+Makie = "=0.20.0"
 MeshIO = "0.4"
 ModernGL = "1"
 Observables = "0.5.1"

GLMakie/assets/shader/distance_shape.frag

@@ -26,6 +26,7 @@ uniform float           stroke_width;
 uniform float           glow_width;
 uniform int             shape; // shape is a uniform for now. Making them a in && using them for control flow is expected to kill performance
 uniform vec2            resolution;
+uniform float           px_per_unit;
 uniform bool            transparent_picking;
 
 flat in float           f_viewport_from_u_scale;
@@ -130,7 +131,9 @@ void stroke(vec4 strokecolor, float signed_distance, float width, inout vec4 col
 
 void glow(vec4 glowcolor, float signed_distance, float inside, inout vec4 color){
     if (glow_width > 0.0){
-        float outside = (abs(signed_distance)-stroke_width)/glow_width;
+        float s_stroke_width = px_per_unit * stroke_width;
+        float s_glow_width = px_per_unit * glow_width;
+        float outside = (abs(signed_distance)-s_stroke_width)/s_glow_width;
         float alpha = 1-outside;
         color = mix(vec4(glowcolor.rgb, glowcolor.a*alpha), color, inside);
     }
@@ -180,13 +183,14 @@ void main(){
     // See notes in geometry shader where f_viewport_from_u_scale is computed.
     signed_distance *= f_viewport_from_u_scale;
 
-    float inside_start = max(-stroke_width, 0.0);
+    float s_stroke_width = px_per_unit * stroke_width;
+    float inside_start = max(-s_stroke_width, 0.0);
     float inside = aastep(inside_start, signed_distance);
     vec4 final_color = f_bg_color;
 
     fill(f_color, image, tex_uv, inside, final_color);
-    stroke(f_stroke_color, signed_distance, -stroke_width, final_color);
-    glow(f_glow_color, signed_distance, aastep(-stroke_width, signed_distance), final_color);
+    stroke(f_stroke_color, signed_distance, -s_stroke_width, final_color);
+    glow(f_glow_color, signed_distance, aastep(-s_stroke_width, signed_distance), final_color);
     // TODO: In 3D, we should arguably discard fragments outside the sprite
     //       But note that this may interfere with object picking.
     // if (final_color == f_bg_color)

GLMakie/assets/shader/line_segment.vert

@@ -16,6 +16,7 @@ in float lastlen;
 uniform mat4 projectionview, model;
 uniform uint objectid;
 uniform float depth_shift;
+uniform float px_per_unit;
 
 out uvec2 g_id;
 out vec4 g_color;
@@ -42,7 +43,7 @@ void main()
     int index = gl_VertexID;
     g_id = uvec2(objectid, index+1);
     g_color = to_color(color, color_map, color_norm, index);
-    g_thickness = thickness;
+    g_thickness = px_per_unit * thickness;
     gl_Position = projectionview * model * to_vec4(vertex);
     gl_Position.z += gl_Position.w * depth_shift;
 }

GLMakie/assets/shader/lines.vert

@@ -26,6 +26,7 @@ vec4 _color(Nothing color, sampler1D intensity, sampler1D color_map, vec2 color_
 uniform mat4 projectionview, model;
 uniform uint objectid;
 uniform int total_length;
+uniform float px_per_unit;
 
 out uvec2 g_id;
 out vec4 g_color;
@@ -50,7 +51,7 @@ void main()
     int index = gl_VertexID;
     g_id = uvec2(objectid, index+1);
     g_valid_vertex = get_valid_vertex(valid_vertex);
-    g_thickness = thickness;
+    g_thickness = px_per_unit * thickness;
 
     g_color = _color(color, intensity, color_map, color_norm, index, total_length);
     #ifdef FAST_PATH

GLMakie/assets/shader/sprites.geom

@@ -38,6 +38,7 @@ uniform float stroke_width;
 uniform float glow_width;
 uniform int shape; // for RECTANGLE hack below
 uniform vec2 resolution;
+uniform float px_per_unit;
 uniform float depth_shift;
 
 in int g_primitive_index[];
@@ -140,7 +141,7 @@ void main(void)
                              0.0,         1.0/vclip.w, 0.0,         0.0,
                              0.0,         0.0,         1.0/vclip.w, 0.0,
                              -vclip.xyz/(vclip.w*vclip.w),          0.0);
-    mat2 dxyv_dxys = diagm(0.5*resolution) * mat2(d_ndc_d_clip*trans);
+    mat2 dxyv_dxys = diagm(0.5*px_per_unit*resolution) * mat2(d_ndc_d_clip*trans);
     // Now, our buffer size is expressed in viewport pixels but we get back to
     // the sprite coordinate system using the scale factor of the
     // transformation (for isotropic transformations). For anisotropic