Updates for GeometryBasics refactor

.github/workflows/ci.yml

@@ -46,6 +46,9 @@ jobs:
           pkg"registry up"
           Pkg.update()
           pkg"dev . ./MakieCore"
+          pkg"add GeometryBasics#ff/refactor"
+          pkg"add MeshIO#ff/GeometryBasics_refactor"
+          pkg"add ShaderAbstractions#ff/GeometryBasics_refactor"
           Pkg.test("Makie"; coverage=true)
 
       - uses: julia-actions/julia-processcoverage@v1

.github/workflows/reference_tests.yml

@@ -45,6 +45,9 @@ jobs:
           # dev mono repo versions
           pkg"registry up"
           Pkg.update()
+          pkg"add MeshIO#ff/GeometryBasics_refactor"
+          pkg"add GeometryBasics#ff/refactor"
+          pkg"add ShaderAbstractions#ff/GeometryBasics_refactor"
           pkg"dev . ./MakieCore ./CairoMakie ./ReferenceTests"
       - name: Run the tests
         continue-on-error: true
@@ -95,6 +98,9 @@ jobs:
           # dev mono repo versions
           pkg"registry up"
           Pkg.update()
+          pkg"add MeshIO#ff/GeometryBasics_refactor"
+          pkg"add GeometryBasics#ff/refactor"
+          pkg"add ShaderAbstractions#ff/GeometryBasics_refactor"
           pkg"dev . ./MakieCore ./GLMakie ./ReferenceTests"
       - name: Run the tests
         id: referencetests
@@ -145,6 +151,9 @@ jobs:
           # dev mono repo versions
           pkg"registry up"
           Pkg.update()
+          pkg"add MeshIO#ff/GeometryBasics_refactor"
+          pkg"add GeometryBasics#ff/refactor"
+          pkg"add ShaderAbstractions#ff/GeometryBasics_refactor"
           pkg"dev . ./MakieCore ./WGLMakie ./ReferenceTests"
       - name: Run the tests
         continue-on-error: true

.github/workflows/rprmakie.yaml

@@ -43,6 +43,9 @@ jobs:
           using Pkg;
           pkg"registry up"
           Pkg.update()
+          pkg"add GeometryBasics#ff/refactor"
+          pkg"add MeshIO#ff/GeometryBasics_refactor"
+          pkg"add ShaderAbstractions#ff/GeometryBasics_refactor"
           # dev mono repo versions
           pkg"dev . ./MakieCore ./RPRMakie ./ReferenceTests"
       - name: Run the tests

CairoMakie/src/primitives.jl

@@ -9,22 +9,6 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Unio
 
     isempty(positions) && return
 
-    # workaround for a LineSegments object created from a GLNormalMesh
-    # the input argument is a view of points using faces, which results in
-    # a vector of tuples of two points. we convert those to a list of points
-    # so they don't trip up the rest of the pipeline
-    # TODO this shouldn't be necessary anymore!
-    if positions isa SubArray{<:Point3, 1, P, <:Tuple{Array{<:AbstractFace}}} where P
-        positions = let
-            pos = Point3f[]
-            for tup in positions
-                push!(pos, tup[1])
-                push!(pos, tup[2])
-            end
-            pos
-        end
-    end
-
     # color is now a color or an array of colors
     # if it's an array of colors, each segment must be stroked separately
     color = to_color(primitive.calculated_colors[])
@@ -1200,7 +1184,7 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Maki
 
     pos = primitive[1][]
     # For correct z-ordering we need to be in view/camera or screen space
-    model = copy(model)
+    model = copy(model)::Mat4d
     view = scene.camera.view[]
 
     zorder = sortperm(pos, by = p -> begin
@@ -1253,10 +1237,18 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Maki
     pos = Makie.voxel_positions(primitive)
     scale = Makie.voxel_size(primitive)
     colors = Makie.voxel_colors(primitive)
-    marker = normal_mesh(Rect3f(Point3f(-0.5), Vec3f(1)))
+
+    # Face culling
+    if !isempty(primitive.clip_planes[]) && Makie.is_data_space(primitive.space[])
+        valid = [is_visible(primitive.clip_planes[], p) for p in pos]
+        pos = pos[valid]
+        colors = colors[valid]
+    end
+
+    marker = GeometryBasics.clear_faceviews(normal_mesh(Rect3f(Point3f(-0.5), Vec3f(1))))
 
     # For correct z-ordering we need to be in view/camera or screen space
-    model = copy(primitive.model[])
+    model = copy(primitive.model[])::Mat4d
     view = scene.camera.view[]
 
     zorder = sortperm(pos, by = p -> begin
@@ -1271,7 +1263,7 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Maki
         specular = primitive.specular, shininess = primitive.shininess,
         faceculling = get(primitive, :faceculling, -10),
         transformation = Makie.transformation(primitive),
-        clip_planes = primitive.clip_planes
+        clip_planes = Plane3f[]
     )
 
     for i in zorder

GLMakie/src/GLAbstraction/GLTexture.jl

@@ -139,7 +139,7 @@ function Texture(s::ShaderAbstractions.Sampler{T, N}; kwargs...) where {T, N}
         pointer(s.data), size(s.data),
         minfilter = s.minfilter, magfilter = s.magfilter,
         x_repeat = s.repeat[1], y_repeat = s.repeat[min(2, N)], z_repeat = s.repeat[min(3, N)],
-        anisotropic = s.anisotropic; kwargs...
+        mipmap = s.mipmap, anisotropic = s.anisotropic; kwargs...
     )
     obsfunc = ShaderAbstractions.connect!(s, tex)
     push!(tex.observers, obsfunc)

GLMakie/src/GLAbstraction/GLTypes.jl

@@ -342,7 +342,6 @@ function RenderObject(
         pre::Pre, post,
         context=current_context()
     ) where Pre
-
     switch_context!(context)
 
     # This is a lazy workaround for disabling updates of `requires_update` when

GLMakie/src/GLAbstraction/GLUniforms.jl

@@ -108,13 +108,15 @@ function glsl_typename(t::Type{T}) where T <: Mat
     string(opengl_prefix(eltype(t)), "mat", M==N ? M : string(N, "x", M))
 end
 toglsltype_string(t::Observable) = toglsltype_string(to_value(t))
-toglsltype_string(x::T) where {T<:Union{Real, Mat, StaticVector, Texture, Colorant, TextureBuffer, Nothing}} = "uniform $(glsl_typename(x))"
+function toglsltype_string(x::T) where {T<:Union{Real, Mat, StaticVector, Texture, Colorant, TextureBuffer, Nothing}}
+    return "uniform $(glsl_typename(x))"
+end
 #Handle GLSL structs, which need to be addressed via single fields
 function toglsltype_string(x::T) where T
     if isa_gl_struct(x)
         string("uniform ", T.name.name)
     else
-        error("can't splice $T into an OpenGL shader. Make sure all fields are of a concrete type and isbits(FieldType)-->true")
+        error("can't splice $T into an OpenGL shader. Make sure all fields are of a concrete type and isbits(FieldType)-->true\n\n$x")
     end
 end
 toglsltype_string(t::Union{GLBuffer{T}, GPUVector{T}}) where {T} = string("in ", glsl_typename(T))
@@ -237,7 +239,7 @@ gl_convert(a::T) where {T <: NATIVE_TYPES} = a
 gl_convert(s::Observable{T}) where {T <: NATIVE_TYPES} = s
 gl_convert(s::Observable{T}) where T = const_lift(gl_convert, s)
 gl_convert(x::StaticVector{N, T}) where {N, T} = map(gl_promote(T), x)
-gl_convert(x::Mat{N, M, T}) where {N, M, T} = map(gl_promote(T), x)
+gl_convert(x::Mat{N, M, T}) where {N, M, T} = Mat{N, M, gl_promote(T)}(x)
 gl_convert(a::AbstractVector{<: AbstractFace}) = indexbuffer(s)
 gl_convert(t::Type{T}, a::T; kw_args...) where T <: NATIVE_TYPES = a
 gl_convert(::Type{<: GPUArray}, a::StaticVector) = gl_convert(a)

GLMakie/src/drawing_primitives.jl

@@ -723,6 +723,7 @@ function mesh_inner(screen::Screen, mesh, transfunc, gl_attributes, plot, space=
     color = pop!(gl_attributes, :color)
     interp = to_value(pop!(gl_attributes, :interpolate, true))
     interp = interp ? :linear : :nearest
+
     if to_value(color) isa Colorant
         gl_attributes[:vertex_color] = color
         delete!(gl_attributes, :color_map)
@@ -739,6 +740,10 @@ function mesh_inner(screen::Screen, mesh, transfunc, gl_attributes, plot, space=
                 return convert_attribute(uv_transform, key"uv_transform"())
             end
         end
+    elseif to_value(color) isa ShaderAbstractions.Sampler
+        gl_attributes[:image] = Texture(lift(el32convert, plot, color))
+        delete!(gl_attributes, :color_map)
+        delete!(gl_attributes, :color_norm)    
     elseif to_value(color) isa AbstractMatrix{<:Colorant}
         gl_attributes[:image] = Texture(lift(el32convert, plot, color), minfilter = interp)
         delete!(gl_attributes, :color_map)
@@ -763,13 +768,14 @@ function mesh_inner(screen::Screen, mesh, transfunc, gl_attributes, plot, space=
     end
 
     # TODO: avoid intermediate observable
-    positions = map(m -> metafree(coordinates(m)), mesh)
+    # TODO: Should these use direct getters? (faces, normals, texturecoordinates)
+    positions = map(coordinates, mesh)
     gl_attributes[:vertices] = apply_transform_and_f32_conversion(plot, pop!(gl_attributes, :f32c), positions)
     gl_attributes[:faces] = lift(x-> decompose(GLTriangleFace, x), mesh)
     if hasproperty(to_value(mesh), :uv)
         gl_attributes[:texturecoordinates] = lift(decompose_uv, mesh)
     end
-    if hasproperty(to_value(mesh), :normals) && (shading !== NoShading || matcap_active)
+    if hasproperty(to_value(mesh), :normal) && (shading !== NoShading || matcap_active)
         gl_attributes[:normals] = lift(decompose_normals, mesh)
     end
     return draw_mesh(screen, gl_attributes)

GLMakie/src/glshaders/mesh.jl

@@ -1,38 +1,37 @@
 function to_opengl_mesh!(result, mesh_obs::TOrSignal{<: GeometryBasics.Mesh})
-    m_attr = map(convert(Observable, mesh_obs)) do m
-        return (m, GeometryBasics.attributes(m))
-    end
-
-    result[:faces] = indexbuffer(map(((m,_),)-> faces(m), m_attr))
-    result[:vertices] = GLBuffer(map(((m, _),) -> metafree(coordinates(m)), m_attr))
-
-    attribs = m_attr[][2]
+    m = convert(Observable, mesh_obs)
+
+    result[:faces]    = indexbuffer(map(faces, m))
+    result[:vertices] = GLBuffer(map(coordinates, m))
 
     function to_buffer(name, target)
-        if haskey(attribs, name)
-            val = attribs[name]
+        if hasproperty(m[], name)
+            val = getproperty(m[], name)
             if mesh_obs isa Observable
-                val = map(((m, a),)-> a[name], m_attr)
+                val = map(m -> getproperty(m, name), m)
             end
             if val[] isa AbstractVector
-                result[target] = GLBuffer(map(metafree, val))
+                result[target] = GLBuffer(val)
             elseif val[] isa AbstractMatrix
                 result[target] = Texture(val)
             else
                 error("unsupported attribute: $(name)")
             end
         end
     end
+
     to_buffer(:color, :vertex_color)
     to_buffer(:uv, :texturecoordinates)
     to_buffer(:uvw, :texturecoordinates)
+
     # Only emit normals, when we shadin'
     shading = get(result, :shading, NoShading)::Makie.MakieCore.ShadingAlgorithm
     matcap_active = !isnothing(to_value(get(result, :matcap, nothing)))
     if matcap_active || shading != NoShading
-        to_buffer(:normals, :normals)
+        to_buffer(:normal, :normals)
     end
     to_buffer(:attribute_id, :attribute_id)
+
     return result
 end
 

RPRMakie/src/meshes.jl

@@ -172,7 +172,7 @@ function to_rpr_object(context, matsys, scene, plot::Makie.Surface)
     faces = decompose(GLTriangleFace, r)
     uv = decompose_uv(r)
     # with this we can beuild a mesh
-    mesh = GeometryBasics.Mesh(meta(vec(positions[]), uv=uv), faces)
+    mesh = GeometryBasics.Mesh(vec(positions[]), faces, uv = uv)
 
     rpr_mesh = RPR.Shape(context, mesh)
     color = plot.color[]

ReferenceTests/src/tests/examples3d.jl

@@ -17,7 +17,7 @@ end
     function colormesh((geometry, color))
         mesh1 = normal_mesh(geometry)
         npoints = length(GeometryBasics.coordinates(mesh1))
-        return GeometryBasics.pointmeta(mesh1; color=fill(color, npoints))
+        return GeometryBasics.mesh(mesh1; color=fill(color, npoints))
     end
     # create an array of differently colored boxes in the direction of the 3 axes
     x = Vec3f(0); baselen = 0.2f0; dirlen = 1f0
@@ -318,7 +318,7 @@ end
     N = 3; nbfacese = 30; radius = 0.02
 
     large_sphere = Sphere(Point3f(0), 1f0)
-    positions = decompose(Point3f, large_sphere, 30)
+    positions = decompose(Point3f, Tesselation(large_sphere, 30))
     np = length(positions)
     pts = [positions[k][l] for k = 1:length(positions), l = 1:3]
     pts = vcat(pts, 1.1 .* pts + RNG.randn(size(pts)) / perturbfactor) # light position influence ?
@@ -423,7 +423,7 @@ end
 end
 
 @reference_test "Normals of a Cat" begin
-    x = loadasset("cat.obj")
+    x = GeometryBasics.clear_faceviews(loadasset("cat.obj"))
     f, a, p = mesh(x, color=:black)
     pos = map(decompose(Point3f, x), GeometryBasics.normals(x)) do p, n
         p => p .+ Point(normalize(n) .* 0.05f0)
@@ -446,7 +446,7 @@ end
     function colormesh((geometry, color))
         mesh1 = normal_mesh(geometry)
         npoints = length(GeometryBasics.coordinates(mesh1))
-        return GeometryBasics.pointmeta(mesh1; color=fill(color, npoints))
+        return GeometryBasics.mesh(mesh1; color=fill(color, npoints))
     end
     # create an array of differently colored boxes in the direction of the 3 axes
     x = Vec3f(0); baselen = 0.2f0; dirlen = 1f0

ReferenceTests/src/tests/primitives.jl

@@ -606,7 +606,7 @@ end
     f, a, p = surface(1..10, 1..10, ns, colormap = [:lightblue, :lightblue])
     # plot a wireframe so we can see what's going on, and in which cells.
     m = Makie.surface2mesh(to_value.(p.converted)...)
-    scatter!(a, m.position, color = isnan.(m.normals), depth_shift = -1f-3)
+    scatter!(a, m.position, color = isnan.(m.normal), depth_shift = -1f-3)
     wireframe!(a, m, depth_shift = -1f-3, color = :black)
     f
 end

WGLMakie/assets/mesh.vert

@@ -96,7 +96,7 @@ void main(){
     }
     vec4 position_world = model * vec4(vertex_position, 1);
 
-    render(position_world, get_normals(), view, projection);
+    render(position_world, get_normal(), view, projection);
     frag_uv = apply_uv_transform(get_uv_transform(), get_uv());
     frag_color = vertex_color(get_color(), get_colorrange(), colormap);
 

WGLMakie/assets/particles.vert

@@ -87,7 +87,7 @@ 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_position());
-    vec3 N = get_normals() / get_markersize(); // see issue #3702
+    vec3 N = get_normal() / get_markersize(); // see issue #3702
     rotate(get_rotation(), vertex_position, N);
     vertex_position = to_vec3(get_offset()) + vertex_position;
     vec4 position_world = model * vec4(vertex_position, 1);

WGLMakie/src/Serialization.js

@@ -66,6 +66,7 @@ export function delete_plots(plot_uuids) {
 function convert_texture(scene, data) {
     const tex = create_texture(scene, data);
     tex.needsUpdate = true;
+    tex.generateMipmaps = data.mipmap;
     tex.minFilter = THREE[data.minFilter];
     tex.magFilter = THREE[data.magFilter];
     tex.anisotropy = data.anisotropy;
@@ -266,12 +267,13 @@ function connect_uniforms(mesh, updater) {
 function convert_RGB_to_RGBA(rgbArray) {
     const length = rgbArray.length;
     const rgbaArray = new rgbArray.constructor((length / 3) * 4);
+    const a = (rgbArray instanceof Uint8Array) ? 255 : 1.0;
 
     for (let i = 0, j = 0; i < length; i += 3, j += 4) {
         rgbaArray[j] = rgbArray[i]; // R
         rgbaArray[j + 1] = rgbArray[i + 1]; // G
         rgbaArray[j + 2] = rgbArray[i + 2]; // B
-        rgbaArray[j + 3] = 1.0; // A
+        rgbaArray[j + 3] = a; // A
     }
 
     return rgbaArray;

WGLMakie/src/imagelike.jl

@@ -33,7 +33,7 @@ function create_shader(mscene::Scene, plot::Surface)
         return invert ? -ns : ns
     end)
 
-    per_vertex = Dict(:positions => positions, :faces => faces, :uv => uv, :normals => normals)
+    per_vertex = Dict(:positions => positions, :faces => faces, :uv => uv, :normal => normals)
     uniforms = Dict(:uniform_color => color, :color => false, :model => model)
 
     # TODO: allow passing Mat{2, 3, Float32} (and nothing)
@@ -54,7 +54,7 @@ function create_shader(mscene::Scene, plot::Union{Heatmap, Image})
     f32c, model = Makie.patch_model(plot)
     mesh = limits_to_uvmesh(plot, f32c)
     uniforms = Dict(
-        :normals => Vec3f(0),
+        :normal => Vec3f(0),
         :shading => false,
         :diffuse => Vec3f(0),
         :specular => Vec3f(0),

WGLMakie/src/meshes.jl

@@ -26,6 +26,8 @@ function handle_color!(plot, uniforms, buffers, uniform_color_name = :uniform_co
 
     if color[] isa Colorant
         uniforms[uniform_color_name] = color
+    elseif color[] isa ShaderAbstractions.Sampler
+        uniforms[uniform_color_name] = to_value(color)
     elseif color[] isa AbstractVector
         buffers[:color] = Buffer(color)
     elseif color[] isa Makie.AbstractPattern
@@ -93,23 +95,22 @@ function draw_mesh(mscene::Scene, per_vertex, plot, uniforms; permute_tex=true)
     uniforms[:object_id] = UInt32(0)
     pos = pop!(per_vertex, :positions)
     faces = pop!(per_vertex, :faces)
-    mesh = GeometryBasics.Mesh(meta(pos; per_vertex...), faces)
+    mesh = GeometryBasics.Mesh(pos, faces; per_vertex...)
     return Program(WebGL(), lasset("mesh.vert"), lasset("mesh.frag"), mesh, uniforms)
 end
 
 function create_shader(scene::Scene, plot::Makie.Mesh)
     # Potentially per instance attributes
     mesh_signal = plot[1]
-    mattributes = GeometryBasics.attributes
     get_attribute(mesh, key) = lift(x -> getproperty(x, key), plot, mesh)
-    data = mattributes(mesh_signal[])
+    data = GeometryBasics.vertex_attributes(mesh_signal[])
 
     uniforms = Dict{Symbol,Any}()
     attributes = Dict{Symbol,Any}()
 
     uniforms[:interpolate_in_fragment_shader] = get(plot, :interpolate_in_fragment_shader, true)
 
-    for (key, default) in (:uv => Vec2f(0), :normals => Vec3f(0))
+    for (key, default) in (:uv => Vec2f(0), :normal => Vec3f(0))
         if haskey(data, key)
             attributes[key] = Buffer(get_attribute(mesh_signal, key))
         else