fixes

Author: SimonDanisch

src/basic_types.jl

@@ -23,8 +23,8 @@ abstract type AbstractSimplex{Dim,N,T} <: StaticVector{Dim,T} end
     return Polytope(P, F)(map(i-> points[i], face.data))
 end
 
-@propagate_inbounds function Base.getindex(points::AbstractVector{P}, face::F) where {P<: Vec, F <: AbstractFace}
-    return map(i-> points[i], face.data)
+@propagate_inbounds function Base.getindex(elements::AbstractVector, face::F) where {F <: AbstractFace}
+    return map(i-> elements[i], face.data)
 end
 
 @fixed_vector SimplexFace AbstractSimplexFace

src/meshes.jl

@@ -107,6 +107,20 @@ function Base.merge(meshes::AbstractVector{<:Mesh})
     end
 end
 
+function Base.merge(meshes::AbstractVector{T}) where T <: MetaMesh
+    isempty(meshes) && return T(Point3f[], GLTriangleFace[])
+    big_mesh = merge(map(Mesh, meshes))
+    big_meta = deepcopy(meta(meshes[1]))
+    for mesh in Iterators.drop(meshes, 1)
+        mm = meta(mesh)
+        for (k, v) in pairs(mm)
+            append!(big_meta[k], v)
+        end
+    end
+    return MetaMesh(big_mesh, big_meta)
+end
+
+
 function map_coordinates(f, mesh::Mesh)
     result = copy(mesh)
     map_coordinates!(f, result)

src/offsetintegers.jl

@@ -5,7 +5,7 @@ OffsetInteger type mainly for indexing.
 * `O` - The offset relative to Julia arrays. This helps reduce copying when
 communicating with 0-indexed systems such as OpenGL.
 """
-struct OffsetInteger{O,T<:Integer}
+struct OffsetInteger{O,T<:Integer} <: Integer
     i::T
     OffsetInteger{O,T}(x::Integer) where {O,T<:Integer} = new{O,T}(T(x + O))
 end
@@ -82,3 +82,13 @@ for op in (:(==), :(>=), :(<=), :(<), :(>), :sub_with_overflow)
         Base.$op(x::Integer, y::OffsetInteger) = $op(x, value(y))
     end
 end
+
+Base.promote_rule(::Type{IT}, ::Type{<:OffsetInteger}) where {IT<:Integer} = IT
+
+function Base.promote_rule(::Type{OffsetInteger{O1,T1}},
+                           ::Type{OffsetInteger{O2,T2}}) where {O1,O2,T1<:Integer,
+                                                                T2<:Integer}
+    return OffsetInteger{pure_max(O1, O2),promote_type(T1, T2)}
+end
+
+Base.@pure pure_max(x1, x2) = x1 > x2 ? x1 : x2

src/viewtypes.jl

@@ -56,11 +56,6 @@ function TupleView{N,M}(x::AbstractVector{T}; connect=false) where {T,N,M}
     return TupleView{NTuple{N,T},N,M,typeof(x)}(x, connect)
 end
 
-function connected_line(points::AbstractVector{<:Point{N}},
-                                skip=N) where {N}
-    return connect(points, Line, skip)
-end
-
 """
     connect(points::AbstractVector{<: Point}, P::Type{<: Polytope{N}}, skip::Int = N)
 
@@ -83,7 +78,7 @@ end
 
 function connect(indices::AbstractVector{T}, P::Type{<:AbstractFace{N}},
                          skip::Int=N) where {T <: Integer, N}
-    return map(Face(P, T), TupleView{N, skip}(indices))
+    return collect(reinterpret(Face(P, T), TupleView{N, skip}(indices)))
 end
 
 function connect(points::AbstractMatrix{T}, P::Type{<:Point{N}}) where {T <: Real, N}