prototype MultiFace Rect -> Mesh pipeline

Author: ffreyer

src/basic_types.jl

@@ -64,16 +64,21 @@ end
 
 MultiFace(; kwargs...) = MultiFace(NamedTuple(kwargs))
 MultiFace{Names}(args...) where {Names} = MultiFace(NamedTuple{Names}(args))
+MultiFace{Names}(args::Tuple{Vararg{<: AbstractFace}}) where {Names} = MultiFace(NamedTuple{Names}(args))
+MultiFace{Names, FT}(args) where {Names, FT <: AbstractFace} = MultiFace(NamedTuple{Names}(FT.(args)))
 
-Base.names(::Type{<: MultiFace{N, T, FT, Names}}) where {N, T, FT, Names} = Names
-function Base.getindex(f::MultiFace{N, T, FT, Names, N_Attrib}, i::Integer) where {N, T, FT, Names, N_Attrib}
-    return ntuple(n -> f.faces[n][i], N_Attrib)
-end
+Base.getindex(f::MultiFace, i::Int64) = Base.getindex(getfield(f, :faces), i) # TODO: StaticVector should index with Integer
+@inline Base.hasproperty(f::MultiFace, field::Symbol) = hasproperty(getfield(f, :faces), field)
+@inline Base.getproperty(f::MultiFace, field::Symbol) = getproperty(getfield(f, :faces), field)
+@inline Base.propertynames(f::MultiFace) = propertynames(getfield(f, :faces))
+@inline Base.propertynames(::Type{<: MultiFace{N, T, FT, Names}}) where {N, T, FT, Names} = Names
 
 # TODO: Some shorthands
 const NormalFace = MultiFace{(:position, :normal)}
 const NormalUVFace = MultiFace{(:position, :normal, :uv)}
 
+# TODO: enable something like NormalUVFace{QuadFace}[...]
+
 @propagate_inbounds Base.getindex(x::Polytope, i::Integer) = coordinates(x)[i]
 @propagate_inbounds Base.iterate(x::Polytope) = iterate(coordinates(x))
 @propagate_inbounds Base.iterate(x::Polytope, i) = iterate(coordinates(x), i)
@@ -340,7 +345,7 @@ struct Mesh{
         end
 
         if FT <: MultiFace
-            f_names = names(FT)
+            f_names = propertynames(FT)
             if Names != f_names
                 error(
                     "Cannot construct a mesh with vertex attribute names $Names and MultiFace " * 

src/meshes.jl

@@ -14,6 +14,7 @@ It also only losely correlates to the number of vertices, depending on the algor
 function mesh(primitive::AbstractGeometry; pointtype=Point, facetype=GLTriangleFace, vertex_attributes...)
     positions = decompose(pointtype, primitive)
     _f = faces(primitive)
+
     # If faces returns nothing for primitive, we try to triangulate!
     if isnothing(_f)
         if eltype(positions) <: Point2
@@ -23,11 +24,30 @@ function mesh(primitive::AbstractGeometry; pointtype=Point, facetype=GLTriangleF
             error("No triangulation for $(typeof(primitive))")
         end
     else
+        if _f isa AbstractVector{<: MultiFace}
+            if facetype isa MultiFace
+                # drop faces that facetype doesn't include
+                names = propertynames(facetype)
+                _f = map(f -> MultiFace{names}(getproperty.((f,), names)), _f)
+            else
+                # drop faces for vertex attributes that aren't given
+                names = (:position, keys(vertex_attributes)...)
+                _f2 = map(f -> MultiFace{names}(getproperty.((f,), names)), _f)
+                
+                # and remap to a simple face type so that decompose can handle the rest
+                _f, mappings = merge_vertex_indices(_f2)
+                positions = positions[mappings[1]]
+                vertex_attributes = NamedTuple(
+                    (Pair(names[i], vertex_attributes[i-1][mappings[i]]) for i in 2:length(mappings))    
+                )
+            end
+        end
         f = decompose(facetype, _f)
     end
     return Mesh(positions, f; vertex_attributes...)
 end
 
+
 const SimpleMesh{N, T, FT} = Mesh{N, T, FT, (:position,), Tuple{Vector{Point{N, T}}}, Vector{FT}}
 const SimpleTriangleMesh{N} = SimpleMesh{N, Float32, GLTriangleFace}
 
@@ -72,20 +92,20 @@ end
 
 function uv_normal_mesh(primitive::AbstractGeometry{N}) where {N}
     return mesh(
-        primitive, uv = decompose_uv(primitive), normals = decompose_normals(primitive),
+        primitive, uv = decompose_uv(primitive), normal = decompose_normals(primitive),
         pointtype=Point{N,Float32}, facetype=GLTriangleFace)
 end
 
 function normal_mesh(points::AbstractVector{<:Point},
                      faces::AbstractVector{<:AbstractFace})
     _points = decompose(Point3f, points)
     _faces = decompose(GLTriangleFace, faces)
-    return Mesh(_faces, position = _points, normals = normals(_points, _faces))
+    return Mesh(_faces, position = _points, normal = normals(_points, _faces))
 end
 
 function normal_mesh(primitive::AbstractGeometry{N}) where {N}
     return mesh(
-        primitive, normals = decompose_normals(primitive), 
+        primitive, normal = decompose_normals(primitive), 
         pointtype=Point{N,Float32}, facetype=GLTriangleFace)
 end
 
@@ -224,7 +244,7 @@ function merge_vertex_indices(
         for i in 1:N
             # get the i-th set of vertex indices from multi_face, i.e.
             # (multi_face.position_index[i], multi_face.normal_index[i], ...)
-            vertex = ntuple(n -> multi_face.faces[n][i], N_Attrib)
+            vertex = ntuple(n -> multi_face[n][i], N_Attrib)
 
             # if the vertex exists, get it's index
             # otherwise register it with the next available vertex index

src/primitives/rectangles.jl

@@ -563,22 +563,33 @@ end
 
 ##
 # Rect3 decomposition
-function coordinates(rect::Rect3)
+function coordinates(rect::Rect3{T}) where T
     # TODO use n
     w = widths(rect)
     o = origin(rect)
-    points = Point{3,Int}[(0, 0, 0), (0, 0, 1), (0, 1, 1), (0, 1, 0), (0, 0, 0), (1, 0, 0),
-                          (1, 0, 1), (0, 0, 1), (0, 0, 0), (0, 1, 0), (1, 1, 0), (1, 0, 0),
-                          (1, 1, 1), (0, 1, 1), (0, 0, 1), (1, 0, 1), (1, 1, 1), (1, 0, 1),
-                          (1, 0, 0), (1, 1, 0), (1, 1, 1), (1, 1, 0), (0, 1, 0), (0, 1, 1)]
-    return ((x .* w .+ o) for x in points)
+    # points = Point{3,Int}[(0, 0, 0), (0, 0, 1), (0, 1, 1), (0, 1, 0), (0, 0, 0), (1, 0, 0),
+    #                       (1, 0, 1), (0, 0, 1), (0, 0, 0), (0, 1, 0), (1, 1, 0), (1, 0, 0),
+    #                       (1, 1, 1), (0, 1, 1), (0, 0, 1), (1, 0, 1), (1, 1, 1), (1, 0, 1),
+    #                       (1, 0, 0), (1, 1, 0), (1, 1, 1), (1, 1, 0), (0, 1, 0), (0, 1, 1)]
+    # return ((x .* w .+ o) for x in points)
+    return Point{3, T}[o + (x, y, z) .* w for x in (0, 1) for y in (0, 1) for z in (0, 1)]
+end
+
+function normals(::Rect3)
+    return Vec3f[(-1,0,0), (1,0,0), (0,-1,0), (0,1,0), (0,0,-1), (0,0,1)]
 end
 
 function texturecoordinates(rect::Rect3)
     return coordinates(Rect3(0, 0, 0, 1, 1, 1))
 end
 
-function faces(rect::Rect3)
-    return QuadFace{Int}[(1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12), (13, 14, 15, 16),
-                         (17, 18, 19, 20), (21, 22, 23, 24),]
+function faces(::Rect3)
+    return NormalUVFace{QuadFace}.([
+        ((1, 2, 3, 4), 1, (1, 2, 3, 4)), # -x
+        ((5, 6, 7, 8), 2, (5, 6, 7, 8)), # +x
+        ((1, 2, 5, 6), 3, (1, 2, 5, 6)), # -y
+        ((3, 4, 7, 8), 4, (3, 4, 7, 8)), # +y
+        ((1, 3, 5, 7), 5, (1, 3, 5, 7)), # -z
+        ((2, 4, 6, 8), 6, (2, 4, 6, 8)), # +z
+    ])
 end