SpecApi

GLMakie/src/GLAbstraction/AbstractGPUArray.jl

@@ -193,12 +193,11 @@ max_dim(t)       = error("max_dim not implemented for: $(typeof(t)). This happen
 function (::Type{GPUArrayType})(data::Observable; kw...) where GPUArrayType <: GPUArray
     gpu_mem = GPUArrayType(data[]; kw...)
     # TODO merge these and handle update tracking during contruction
-    obs1 = on(_-> gpu_mem.requires_update[] = true, data)
     obs2 = on(new_data -> update!(gpu_mem, new_data), data)
     if GPUArrayType <: TextureBuffer
-        push!(gpu_mem.buffer.observers, obs1, obs2)
+        push!(gpu_mem.buffer.observers, obs2)
     else
-        push!(gpu_mem.observers, obs1, obs2)
+        push!(gpu_mem.observers, obs2)
     end
     return gpu_mem
 end

GLMakie/src/GLAbstraction/GLBuffer.jl

@@ -5,7 +5,6 @@ mutable struct GLBuffer{T} <: GPUArray{T, 1}
     usage::GLenum
     context::GLContext
     # TODO maybe also delay upload to when render happens?
-    requires_update::Observable{Bool}
     observers::Vector{Observables.ObserverFunction}
 
     function GLBuffer{T}(ptr::Ptr{T}, buff_length::Int, buffertype::GLenum, usage::GLenum) where T
@@ -18,8 +17,7 @@ mutable struct GLBuffer{T} <: GPUArray{T, 1}
 
         obj = new(
             id, (buff_length,), buffertype, usage, current_context(),
-            Observable(true), Observables.ObserverFunction[])
-
+            Observables.ObserverFunction[])
         finalizer(free, obj)
         obj
     end
@@ -68,7 +66,6 @@ function GLBuffer(
     au = ShaderAbstractions.updater(buffer)
     obsfunc = on(au.update) do (f, args)
         f(b, args...) # forward setindex! etc
-        b.requires_update[] = true
         return
     end
     push!(b.observers, obsfunc)

GLMakie/src/GLAbstraction/GLRender.jl

@@ -55,8 +55,6 @@ So rewriting this function could get us a lot of performance for scenes with
 a lot of objects.
 """
 function render(renderobject::RenderObject, vertexarray=renderobject.vertexarray)
-    renderobject.requires_update = false
-
     if renderobject.visible
         renderobject.prerenderfunction()
         program = vertexarray.program

GLMakie/src/GLAbstraction/GLShader.jl

@@ -249,7 +249,7 @@ function gl_convert(cache::ShaderCache, lazyshader::AbstractLazyShader, data)
         template_keys[i] = template
         replacements[i] = String[mustache2replacement(t, v, data) for t in template]
     end
-    program = get!(cache.program_cache, (paths, replacements)) do
+    return get!(cache.program_cache, (paths, replacements)) do
         # when we're here, this means there were uncached shaders, meaning we definitely have
         # to compile a new program
         shaders = Vector{Shader}(undef, length(paths))

GLMakie/src/GLAbstraction/GLTexture.jl

@@ -17,7 +17,6 @@ mutable struct Texture{T <: GLArrayEltypes, NDIM} <: OpenglTexture{T, NDIM}
     parameters      ::TextureParameters{NDIM}
     size            ::NTuple{NDIM, Int}
     context         ::GLContext
-    requires_update ::Observable{Bool}
     observers       ::Vector{Observables.ObserverFunction}
     function Texture{T, NDIM}(
             id              ::GLuint,
@@ -37,7 +36,6 @@ mutable struct Texture{T <: GLArrayEltypes, NDIM} <: OpenglTexture{T, NDIM}
             parameters,
             size,
             current_context(),
-            Observable(true),
             Observables.ObserverFunction[]
         )
         finalizer(free, tex)
@@ -49,11 +47,8 @@ end
 mutable struct TextureBuffer{T <: GLArrayEltypes} <: OpenglTexture{T, 1}
     texture::Texture{T, 1}
     buffer::GLBuffer{T}
-    requires_update::Observable{Bool}
-
     function TextureBuffer(texture::Texture{T, 1}, buffer::GLBuffer{T}) where T
-        x = map((_, _) -> true, buffer.requires_update, texture.requires_update)
-        new{T}(texture, buffer, x)
+        new{T}(texture, buffer)
     end
 end
 Base.size(t::TextureBuffer) = size(t.buffer)
@@ -72,7 +67,6 @@ ShaderAbstractions.switch_context!(t::TextureBuffer) = switch_context!(t.texture
 function unsafe_free(tb::TextureBuffer)
     unsafe_free(tb.texture)
     unsafe_free(tb.buffer)
-    Observables.clear(tb.requires_update)
 end
 
 is_texturearray(t::Texture) = t.texturetype == GL_TEXTURE_2D_ARRAY
@@ -148,8 +142,7 @@ function Texture(s::ShaderAbstractions.Sampler{T, N}; kwargs...) where {T, N}
         anisotropic = s.anisotropic; kwargs...
     )
     obsfunc = ShaderAbstractions.connect!(s, tex)
-    obsfunc2 = on(x -> tex.requires_update[] = true, s.updates.update)
-    push!(tex.observers, obsfunc, obsfunc2)
+    push!(tex.observers, obsfunc)
     return tex
 end
 

GLMakie/src/GLAbstraction/GLTypes.jl

@@ -174,21 +174,8 @@ mutable struct GLVertexArray{T}
     buffers::Dict{String,GLBuffer}
     indices::T
     context::GLContext
-    requires_update::Observable{Bool}
-
     function GLVertexArray{T}(program, id, bufferlength, buffers, indices) where T
-        va = new(program, id, bufferlength, buffers, indices, current_context(), true)
-        if indices isa GLBuffer
-            on(indices.requires_update) do _ # only triggers true anyway
-                va.requires_update[] = true
-            end
-        end
-        for (name, buffer) in buffers
-            on(buffer.requires_update) do _ # only triggers true anyway
-                va.requires_update[] = true
-            end
-        end
-
+        va = new(program, id, bufferlength, buffers, indices, current_context())
         return va
     end
 end
@@ -318,15 +305,14 @@ mutable struct RenderObject{Pre}
     prerenderfunction::Pre
     postrenderfunction
     id::UInt32
-    requires_update::Bool
     visible::Bool
 
     function RenderObject{Pre}(
             context,
             uniforms::Dict{Symbol,Any}, observables::Vector{Observable},
             vertexarray::GLVertexArray,
             prerenderfunctions, postrenderfunctions,
-            visible, track_updates = true
+            visible
         ) where Pre
         fxaa = Bool(to_value(get!(uniforms, :fxaa, true)))
         RENDER_OBJECT_ID_COUNTER[] += one(UInt32)
@@ -340,57 +326,13 @@ mutable struct RenderObject{Pre}
             context,
             uniforms, observables, vertexarray,
             prerenderfunctions, postrenderfunctions,
-            id, true, visible[]
+            id, visible[]
         )
-
-        if track_updates
-            # visible changes should always trigger updates so that plots
-            # actually become invisible when visible is changed.
-            # Other uniforms and buffers don't need to trigger updates when
-            # visible = false
-            on(visible) do visible
-                robj.visible = visible
-                robj.requires_update = true
-            end
-
-            function request_update(_::Any)
-                if robj.visible
-                    robj.requires_update = true
-                end
-                return
-            end
-
-            # gather update requests for polling in renderloop
-            for uniform in values(uniforms)
-                if uniform isa Observable
-                    on(request_update, uniform)
-                elseif uniform isa GPUArray
-                    on(request_update, uniform.requires_update)
-                end
-            end
-            on(request_update, vertexarray.requires_update)
-        else
-            on(visible) do visible
-                robj.visible = visible
-            end
-
-            # remove tracking from GPUArrays
-            for uniform in values(uniforms)
-                if uniform isa GPUArray
-                    foreach(off, uniform.requires_update.inputs)
-                    empty!(uniform.requires_update.inputs)
-                end
-            end
-            for buffer in vertexarray.buffers
-                if buffer isa GPUArray
-                    foreach(off, buffer.requires_update.inputs)
-                    empty!(buffer.requires_update.inputs)
-                end
-            end
-            foreach(off, vertexarray.requires_update.inputs)
-            empty!(vertexarray.requires_update.inputs)
+        push!(observables, visible)
+        on(visible) do visible
+            robj.visible = visible
+            return
         end
-
         return robj
     end
 end
@@ -474,8 +416,7 @@ function RenderObject(
         vertexarray,
         pre,
         post,
-        visible,
-        track_updates
+        visible
     )
 
     # automatically integrate object ID, will be discarded if shader doesn't use it
@@ -502,7 +443,6 @@ function clean_up_observables(x::T) where T
         foreach(off, x.observers)
         empty!(x.observers)
     end
-    Observables.clear(x.requires_update)
 end
 
 # OpenGL has the annoying habit of reusing id's when creating a new context

GLMakie/src/GLAbstraction/GLUniforms.jl

@@ -261,16 +261,4 @@ function gl_convert(::Type{T}, a::Observable{<: AbstractArray{X, N}}; kw_args...
     T(s; kw_args...)
 end
 
-lift_convert(a::AbstractArray, T, N) = lift(x -> convert(Array{T, N}, x), a)
-function lift_convert(a::ShaderAbstractions.Sampler, T, N)
-    ShaderAbstractions.Sampler(
-        lift(x -> convert(Array{T, N}, x.data), a),
-        minfilter = a[].minfilter, magfilter = a[].magfilter,
-        x_repeat = a[].repeat[1],
-        y_repeat = a[].repeat[min(2, N)],
-        z_repeat = a[].repeat[min(3, N)],
-        anisotropic = a[].anisotropic, swizzle_mask = a[].swizzle_mask
-    )
-end
-
 gl_convert(f::Function, a) = f(a)

GLMakie/src/GLMakie.jl

@@ -43,7 +43,16 @@ export Sampler, Buffer
 
 const GL_ASSET_DIR = RelocatableFolders.@path joinpath(@__DIR__, "..", "assets")
 const SHADER_DIR = RelocatableFolders.@path joinpath(GL_ASSET_DIR, "shader")
-loadshader(name) = joinpath(SHADER_DIR, name)
+const LOADED_SHADERS = Dict{String, String}()
+
+function loadshader(name)
+    # Turns out, joinpath is so slow, that it actually makes sense
+    # To memoize it :-O
+    # when creating 1000 plots with the PlotSpec API, timing drop from 1.5s to 1s just from this change:
+    return get!(LOADED_SHADERS, name) do
+        return joinpath(SHADER_DIR, name)
+    end
+end
 
 gl_texture_atlas() = Makie.get_texture_atlas(2048, 64)