Plot update refactor (prototype)

GLMakie/assets/shader/dots.vert

@@ -4,7 +4,7 @@ struct Nothing{ //Nothing type, to encode if some variable doesn't contain any d
     bool _; //empty structs are not allowed
 };
 
-{{vertex_type}}     vertex;
+{{position_type}}   position;
 {{color_type}}      color;
 {{color_norm_type}} color_norm;
 {{color_map_type}}  color_map;
@@ -56,7 +56,7 @@ uniform float px_per_unit;
 uniform vec3 upvector;
 
 void main(){
-    vec4 world_position = model * _position(vertex);
+    vec4 world_position = model * _position(position);
     process_clip_planes(world_position.xyz);
     vec4 clip_pos = projectionview * world_position;
     gl_Position = vec4(clip_pos.xy, clip_pos.z + (clip_pos.w * depth_shift), clip_pos.w);

GLMakie/src/GLAbstraction/GLRenderObject.jl

@@ -4,6 +4,7 @@ end
 
 Base.getindex(obj::RenderObject, symbol::Symbol) = obj.uniforms[symbol]
 Base.setindex!(obj::RenderObject, value, symbol::Symbol) = obj.uniforms[symbol] = value
+Base.haskey(obj::RenderObject, symbol::Symbol) = haskey(obj.uniforms, symbol)
 
 Base.getindex(obj::RenderObject, symbol::Symbol, x::Function) = getindex(obj, Val(symbol), x)
 Base.getindex(obj::RenderObject, ::Val{:prerender}, x::Function) = obj.prerenderfunctions[x]

GLMakie/src/GLAbstraction/GLTypes.jl

@@ -128,12 +128,12 @@ end
 ########################################################################################
 # OpenGL Arrays
 
-const GLArrayEltypes = Union{StaticVector,Real,Colorant}
+const GLArrayEltypes = Union{StaticVector,Quaternion,Real,Colorant}
 """
 Transform julia datatypes to opengl enum type
 """
 julia2glenum(x::Type{T}) where {T <: FixedPoint} = julia2glenum(FixedPointNumbers.rawtype(x))
-julia2glenum(x::Union{Type{T},T}) where {T <: Union{StaticVector,Colorant}} = julia2glenum(eltype(x))
+julia2glenum(x::Union{Type{T},T}) where {T <: Union{StaticVector,Colorant,Quaternion}} = julia2glenum(eltype(x))
 julia2glenum(::Type{OffsetInteger{O,T}}) where {O,T} = julia2glenum(T)
 julia2glenum(::Type{GLubyte})  = GL_UNSIGNED_BYTE
 julia2glenum(::Type{GLbyte})   = GL_BYTE
@@ -281,12 +281,14 @@ end
 
 
 function Base.show(io::IO, vao::GLVertexArray)
-    show(io, vao.program)
+    # show(io, vao.program)
     println(io, "GLVertexArray $(vao.id):")
-    print(io, "GLVertexArray $(vao.id) buffers: ")
-    writemime(io, MIME("text/plain"), vao.buffers)
-    println(io, "\nGLVertexArray $(vao.id) indices: ", vao.indices)
+    print(io, "buffers: ")
+    show(io, MIME("text/plain"), vao.buffers)
+    _print_indices(io, vao.indices)
 end
+_print_indices(io::IO, is::AbstractVector{<: Integer}) = println(io, "\nindices: ", Int64.(is))
+_print_indices(io::IO, fs) = println(io, "\nfaces: ", fs)
 
 ##################################################################################
 

GLMakie/src/GLAbstraction/GLUniforms.jl

@@ -5,7 +5,7 @@
 
 const GLSL_COMPATIBLE_NUMBER_TYPES = (GLfloat, GLint, GLuint, GLdouble)
 const NATIVE_TYPES = Union{
-    StaticVector, Mat, GLSL_COMPATIBLE_NUMBER_TYPES...,
+    StaticVector, Mat, Quaternion, GLSL_COMPATIBLE_NUMBER_TYPES...,
     ZeroIndex{GLint}, ZeroIndex{GLuint},
     GLBuffer, GPUArray, Shader, GLProgram
 }
@@ -35,18 +35,20 @@ end
 
 gluniform(location::Integer, x::Nothing) = nothing
 
-function gluniform(location::Integer, x::Union{StaticVector, Mat, Colorant})
+function gluniform(location::Integer, x::Union{StaticVector, Mat, Colorant, Quaternion})
     xref = [x]
     gluniform(location, xref)
 end
 
 _size(p) = size(p)
 _size(p::Colorant) = (length(p),)
+_size(::Type{<: Quaternion}) = (4,)
 _size(p::Type{T}) where {T <: Colorant} = (length(p),)
 _ndims(p) = ndims(p)
 _ndims(p::Type{T}) where {T <: Colorant} = 1
+_ndims(p::Type{T}) where {T <: Quaternion} = 1
 
-@generated function gluniform(location::Integer, x::Vector{FSA}) where FSA <: Union{Mat, Colorant, StaticVector}
+@generated function gluniform(location::Integer, x::Vector{FSA}) where FSA <: Union{Mat, Colorant, StaticVector, Quaternion}
     func = uniformfunc(eltype(FSA), _size(FSA))
     callexpr = if _ndims(FSA) == 2
         :($func(location, length(x), GL_FALSE, x))
@@ -76,6 +78,7 @@ function gluniform(loc::Integer, x::Observable{T}) where T
     gluniform(GLint(loc), to_value(x))
 end
 
+gluniform(location::Integer, x::Int64) = glUniform1i(GLint(location), GLint(x))
 gluniform(location::Integer, x::Union{GLubyte, GLushort, GLuint}) = glUniform1ui(GLint(location), x)
 gluniform(location::Integer, x::Union{GLbyte, GLshort, GLint, Bool}) = glUniform1i(GLint(location),  x)
 gluniform(location::Integer, x::GLfloat) = glUniform1f(GLint(location),  x)
@@ -94,7 +97,7 @@ glsl_typename(t::Type{GLfloat}) = "float"
 glsl_typename(t::Type{GLdouble}) = "double"
 glsl_typename(t::Type{GLuint}) = "uint"
 glsl_typename(t::Type{GLint}) = "int"
-glsl_typename(t::Type{T}) where {T <: Union{StaticVector, Colorant}} = string(opengl_prefix(eltype(T)), "vec", length(T))
+glsl_typename(t::Type{T}) where {T <: Union{StaticVector, Colorant, Quaternion}} = string(opengl_prefix(eltype(T)), "vec", length(T))
 glsl_typename(t::Type{TextureBuffer{T}}) where {T} = string(opengl_prefix(eltype(T)), "samplerBuffer")
 
 function glsl_typename(t::Texture{T, D}) where {T, D}
@@ -108,7 +111,9 @@ 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, Quaternion, 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)
@@ -187,6 +192,7 @@ gl_promote(x::Type{T}) where {T <: BGR} = BGR{gl_promote(eltype(T))}
 
 gl_promote(x::Type{Vec{N, T}}) where {N, T} = Vec{N, gl_promote(T)}
 gl_promote(x::Type{Point{N, T}}) where {N, T} = Point{N, gl_promote(T)}
+gl_promote(x::Type{Quaternion{T}}) where {T} = Quaternion{gl_promote(T)}
 
 gl_convert(x::AbstractVector{Vec3f}) = x
 
@@ -237,6 +243,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::Quaternion{T}) where {T} = convert(Quaternion{gl_promote(T)}, x)
 gl_convert(x::Mat{N, M, T}) where {N, M, T} = map(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

GLMakie/src/drawing_primitives.jl

@@ -478,6 +478,7 @@ function draw_atomic(screen::Screen, scene::Scene, @nospecialize(plot::Union{Sca
     end
 end
 
+#=
 function draw_atomic(screen::Screen, scene::Scene, @nospecialize(plot::Lines))
     return cached_robj!(screen, scene, plot) do gl_attributes
         linestyle = pop!(gl_attributes, :linestyle)
@@ -541,6 +542,7 @@ function draw_atomic(screen::Screen, scene::Scene, @nospecialize(plot::Lines))
         return draw_lines(screen, positions, data)
     end
 end
+=#
 
 function draw_atomic(screen::Screen, scene::Scene, @nospecialize(plot::LineSegments))
     return cached_robj!(screen, scene, plot) do gl_attributes

GLMakie/src/gl_backend.jl

@@ -75,4 +75,5 @@ include("picking.jl")
 include("rendering.jl")
 include("events.jl")
 include("drawing_primitives.jl")
+include("plot_updates.jl")
 include("display.jl")

GLMakie/src/glshaders/particles.jl

@@ -25,7 +25,7 @@ vec2quaternion(rotation::VectorTypes) = const_lift(x-> vec2quaternion.(x), rotat
 vec2quaternion(rotation::Observable) = lift(vec2quaternion, rotation)
 vec2quaternion(rotation::Makie.Quaternion)= Vec4f(rotation.data)
 vec2quaternion(rotation)= vec2quaternion(to_rotation(rotation))
-GLAbstraction.gl_convert(rotation::Makie.Quaternion)= Vec4f(rotation.data)
+# GLAbstraction.gl_convert(rotation::Makie.Quaternion)= Vec4f(rotation.data)
 to_pointsize(x::Number) = Float32(x)
 to_pointsize(x) = Float32(x[1])
 struct PointSizeRender