slice_mesh

// store a list of all new edges
// join up edges that share vertices
// create closing faces from joined up edges
// create triangles from faces

slice_geometry(geometry, plane)

    faces = []
    verts = []

    distances = []
    positions = []

    for vert in geometry.verts
        distances.push(distance(vert, plane))
        positions.push(position(dist))

    for face in geometry.faces

        last_vert_index = face.verts[face.verts.length - 1]
        last_dist = distances[last_vert_index]
        last_position = positions[last_dist_index]

        for vert_index, i in face.verts
            dist = distances[vert_index]
            position = positions[vert_index]
            new_face = []

             // every pair of new intersections is a new edge that needs to be
             // joined into a closing face

            if position is FRONT:
                if last_position in [FRONT, ON]:
                    new_face.push(add(vert))
                if last_position is BEHIND:
                    new_face.push(add_intersection(last_vert, vert, last_dist, dist))
                    new_face.push(add(vert))

            if position is ON:
                if last_position in [FRONT, ON]:
                    new_face.push(add(vert))
                if last_position is BEHIND:
                    new_face.push(add(vert))

            if position is BEHIND:
                if last_position in FRONT:
                    new_face.push(add_intersection(last_vert, vert, last_dist, dist))

            last_vert = vert
            last_position = position
            last_dist = dist

        if new_face.length:
            faces.push(new_face)

    add_faces_from_chains(chains)
    
    return {
        faces: faces,
        verts: verts
    }


distance(vert, plane):
    distance from slice plane to vert


position(dist):
    if dist == 0:
        return ON
    if dist < 0:
        return BEHIND
    if dist > 0:
        return FRONT


add(vert):
    if vert not in in list:
        add vert
    return vert index


add_intersection(vert1, vert2, last_dist, dist):
    if (vert1, vert2) not in in intersrction_list:
        find intersection vert
        add vert
    return vert index


add_faces_from_chains(chains)
    changes = true
    while changes:
        changes = connect_chains(chains)

    for chain in chains:
        if chain.start == chain.end
            faces.push(chain)


connect_chains(chains)
    for chainA, i in chains:
        for chainB, j in chains:
            merged = merge_chains(chainA, chainB)
            if merged:
                delete chains[j]
                return true
    return false


merge_chains(chainA, chainB)

    if chainA == chainB:
        return false

    if chain_start(chainA) == chain_end(chainB):
        chainA.unshift(*chainB)
        return true

    if chain_start(chainA) == chain_start(chainB):
        reverse_chain(chainB)
        chainA.unshift(*chainB)
        return true

    if chain_end(chainA) == chain_start(chainB):
        chainA.push(*chainB)
        return true

    if chain_end(chainA) == chain_end(chainB):
        reverse_chain(chainB)
        chainA.push(*chainB)
        return true

    return false


chain_start(chain)
    return chain[0][0]


chain_end(chain)
    return chain[chain.length - 1][1]


reverse_chain(chain)
    chain.reverse()
    for edge in chain:
        edge.reverse()