Render on demand

GLMakie/src/GLAbstraction/AbstractGPUArray.jl

@@ -193,8 +193,10 @@ max_dim(t)       = error("max_dim not implemented for: $(typeof(t)). This happen
 
 function (::Type{T})(x::Observable; kw...) where T <: GPUArray
     gpu_mem = T(x[]; kw...)
-    on(x-> update!(gpu_mem, x), x)
-    gpu_mem
+    # TODO merge these and handle update tracking during contruction
+    map!(_ -> true, gpu_mem.requires_update, x)
+    on(x -> update!(gpu_mem, x), x)
+    return gpu_mem
 end
 
 const BaseSerializer = Serialization.AbstractSerializer

GLMakie/src/GLAbstraction/GLBuffer.jl

@@ -4,6 +4,8 @@ mutable struct GLBuffer{T} <: GPUArray{T, 1}
     buffertype  ::GLenum
     usage       ::GLenum
     context     ::GLContext
+    # TODO maybe also delay upload to when render happens?
+    requires_update::Observable{Bool}
 
     function GLBuffer{T}(ptr::Ptr{T}, buff_length::Int, buffertype::GLenum, usage::GLenum) where T
         id = glGenBuffers()
@@ -13,7 +15,7 @@ mutable struct GLBuffer{T} <: GPUArray{T, 1}
         glBufferData(buffertype, buff_length * sizeof(T), ptr, usage)
         glBindBuffer(buffertype, 0)
 
-        obj = new(id, (buff_length,), buffertype, usage, current_context())
+        obj = new(id, (buff_length,), buffertype, usage, current_context(), Observable(true))
         finalizer(free, obj)
         obj
     end

GLMakie/src/GLAbstraction/GLRender.jl

@@ -15,7 +15,7 @@ function render(list::Vector{RenderObject{Pre}}) where Pre
     glUseProgram(program.id)
     bind(vertexarray)
     for renderobject in list
-        Bool(to_value(renderobject.uniforms[:visible])) || continue # skip invisible
+        renderobject.visible || continue # skip invisible
         # make sure we only bind new programs and vertexarray when it is actually
         # different from the previous one
         if renderobject.vertexarray != vertexarray
@@ -55,7 +55,9 @@ 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)
-    if Bool(to_value(renderobject.uniforms[:visible]))
+    if renderobject.visible
+        renderobject.requires_update = false
+
         renderobject.prerenderfunction()
         program = vertexarray.program
         glUseProgram(program.id)

GLMakie/src/GLAbstraction/GLTexture.jl

@@ -17,6 +17,7 @@ mutable struct Texture{T <: GLArrayEltypes, NDIM} <: OpenglTexture{T, NDIM}
     parameters      ::TextureParameters{NDIM}
     size            ::NTuple{NDIM, Int}
     context         ::GLContext
+    requires_update ::Observable{Bool}
     function Texture{T, NDIM}(
             id              ::GLuint,
             texturetype     ::GLenum,
@@ -34,7 +35,8 @@ mutable struct Texture{T <: GLArrayEltypes, NDIM} <: OpenglTexture{T, NDIM}
             format,
             parameters,
             size,
-            current_context()
+            current_context(),
+            Observable(true)
         )
         finalizer(free, tex)
         tex
@@ -45,6 +47,12 @@ 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)
+    end
 end
 Base.size(t::TextureBuffer) = size(t.buffer)
 Base.size(t::TextureBuffer, i::Integer) = size(t.buffer, i)

GLMakie/src/GLAbstraction/GLTypes.jl

@@ -174,9 +174,17 @@ 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
-        new(program, id, bufferlength, buffers, indices, current_context())
+        va = new(program, id, bufferlength, buffers, indices, current_context(), true)
+        for (name, buffer) in buffers
+            on(buffer.requires_update) do _ # only triggers true anyway
+                va.requires_update[] = true
+            end
+        end
+
+        return va
     end
 end
 
@@ -297,11 +305,15 @@ 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
+            prerenderfunctions, postrenderfunctions,
+            track_updates = true
         ) where Pre
         fxaa = to_value(pop!(uniforms, :fxaa, true))
         RENDER_OBJECT_ID_COUNTER[] += one(UInt32)
@@ -311,12 +323,64 @@ mutable struct RenderObject{Pre}
         # But with this implementation, the fxaa flag can't be changed,
         # and since this is a UUID, it shouldn't matter
         id = pack_bool(RENDER_OBJECT_ID_COUNTER[], fxaa)
-        new(
+        visible = pop!(uniforms, :visible, Observable(true))
+
+        robj = new(
             context,
             uniforms, observables, vertexarray,
             prerenderfunctions, postrenderfunctions,
-            id
+            id, true, 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)
+        end
+
+        return robj
     end
 end
 
@@ -328,6 +392,11 @@ function RenderObject(
 
     switch_context!(context)
 
+    # This is a lazy workaround for disabling updates of `requires_update` when
+    # not rendering on demand. A cleaner implementation should probably go 
+    # through @gen_defaults! and adjust constructors instead.
+    track_updates = to_value(pop!(data, :track_updates, true))
+
     targets = get(data, :gl_convert_targets, Dict())
     delete!(data, :gl_convert_targets)
     passthrough = Dict{Symbol,Any}() # we also save a few non opengl related values in data
@@ -359,7 +428,7 @@ function RenderObject(
     end
     buffers = filter(((key, value),) -> isa(value, GLBuffer) || key == :indices, data)
     uniforms = filter(((key, value),) -> !isa(value, GLBuffer) && key != :indices, data)
-    get!(data, :visible, true) # make sure, visibility is set
+    get!(data, :visible, Observable(true)) # make sure this exists
     merge!(data, passthrough) # in the end, we insert back the non opengl data, to keep things simple
     p = gl_convert(to_value(program), data) # "compile" lazyshader
     vertexarray = GLVertexArray(Dict(buffers), p)
@@ -370,6 +439,7 @@ function RenderObject(
         vertexarray,
         pre,
         post,
+        track_updates
     )
     # automatically integrate object ID, will be discarded if shader doesn't use it
     robj[:objectid] = robj.id

GLMakie/src/drawing_primitives.jl

@@ -83,9 +83,9 @@ function cached_robj!(robj_func, screen, scene, x::AbstractPlot)
     robj = get!(screen.cache, objectid(x)) do
         filtered = filter(x.attributes) do (k, v)
             !in(k, (
-                :transformation, :tickranges, :ticklabels, :raw, :SSAO,
-                :lightposition, :material,
-                :inspector_label, :inspector_hover, :inspector_clear
+                :transformation, :tickranges, :ticklabels, :raw, :SSAO, 
+                :lightposition, :material, 
+                :inspector_label, :inspector_hover, :inspector_clear, :inspectable
             ))
         end
 
@@ -105,6 +105,7 @@ function cached_robj!(robj_func, screen, scene, x::AbstractPlot)
         if !isnothing(ambientlight)
             gl_attributes[:ambient] = ambientlight.color
         end
+        gl_attributes[:track_updates] = screen.config.render_on_demand
 
         robj = robj_func(gl_attributes)
 

GLMakie/src/screen.jl

@@ -17,6 +17,7 @@ function renderloop end
 
 * `pause_renderloop = false`: creates a screen with paused renderlooop. Can be started with `GLMakie.start_renderloop!(screen)` or paused again with `GLMakie.pause_renderloop!(screen)`.
 * `vsync = false`: enables vsync for the window.
+* `render_on_demand = true`: renders the scene only if something has changed in it.
 * `framerate = 30.0`: sets the currently rendered frames per second.
 
 ## GLFW window attributes
@@ -40,6 +41,7 @@ mutable struct ScreenConfig
     renderloop::Function
     pause_renderloop::Bool
     vsync::Bool
+    render_on_demand::Bool
     framerate::Float64
 
     # GLFW window attributes
@@ -62,6 +64,7 @@ mutable struct ScreenConfig
             renderloop::Union{Makie.Automatic, Function},
             pause_renderloop::Bool,
             vsync::Bool,
+            render_on_demand::Bool,
             framerate::Number,
             # GLFW window attributes
             float::Bool,
@@ -82,6 +85,7 @@ mutable struct ScreenConfig
             renderloop isa Makie.Automatic ? GLMakie.renderloop : renderloop,
             pause_renderloop,
             vsync,
+            render_on_demand,
             framerate,
             # GLFW window attributes
             float,
@@ -674,12 +678,44 @@ function fps_renderloop(screen::Screen)
     end
 end
 
+
+function requires_update(screen::Screen)
+    for (_, _, robj) in screen.renderlist
+        robj.requires_update && return true
+    end
+    return false
+end
+
+function on_demand_renderloop(screen::Screen)
+    while isopen(screen) && !screen.stop_renderloop
+        t = time_ns()
+        time_per_frame = 1.0 / screen.config.framerate
+        pollevents(screen) # GLFW poll
+
+        if !screen.config.pause_renderloop && requires_update(screen)
+            render_frame(screen)
+            GLFW.SwapBuffers(to_native(screen))
+        end
+
+        t_elapsed = (time_ns() - t) / 1e9
+        diff = time_per_frame - t_elapsed
+        if diff > 0.001 # can't sleep less than 0.001
+            sleep(diff)
+        else # if we don't sleep, we still need to yield explicitely to other tasks
+            yield()
+        end
+    end
+end
+
 function renderloop(screen)
     isopen(screen) || error("Screen most be open to run renderloop!")
     # Context needs to be current for GLFW.SwapInterval
     ShaderAbstractions.switch_context!(screen.glscreen)
     try
-        if screen.config.vsync
+        if screen.config.render_on_demand
+            GLFW.SwapInterval(0)
+            on_demand_renderloop(screen)
+        elseif screen.config.vsync
             GLFW.SwapInterval(1)
             vsynced_renderloop(screen)
         else

NEWS.md

@@ -2,6 +2,8 @@
 
 ## master
 
+- Add "render_on_demand" flag for GLMakie. Setting this to `true` will skip rendering until plots get updated. [#2336](https://github.com/MakieOrg/Makie.jl/pull/2336)
+
 ## v0.18.1
 
 - fix heatmap interpolation [#2343](https://github.com/MakieOrg/Makie.jl/pull/2343).

src/theming.jl

@@ -106,6 +106,7 @@ const minimal_default = Attributes(
         renderloop = automatic,
         pause_renderloop = false,
         vsync = false,
+        render_on_demand = true,
         framerate = 30.0,
 
         # GLFW window attributes