Method updateOutline

src/SFML/Graphics/Shape.cpp:298–397

///////////////////////////////////////////////////////

////////////////////////////////////////////////////////////
void Shape::updateOutline()
{
    // Return if there is no outline or no vertices
    if (m_outlineThickness == 0.f || m_vertices.getVertexCount() < 2)
    {
        m_outlineVertices.clear();
        m_bounds = m_insideBounds;
        return;
    }

    const std::size_t count = m_vertices.getVertexCount() - 2;
    m_outlineVertices.resize((count + 1) * 2); // We need at least that many vertices.
                                               // We will add two more vertices each time we need a bevel.

    // Determine if points are defined clockwise or counterclockwise. This will impact normals computation.
    const bool flipNormals = [this, count]()
    {
        // p0 is either strictly inside the shape, or on an edge.
        const sf::Vector2f p0 = m_vertices[0].position;
        for (std::size_t i = 0; i < count; ++i)
        {
            const sf::Vector2f p1      = m_vertices[i + 1].position;
            const sf::Vector2f p2      = m_vertices[i + 2].position;
            const float        product = (p1 - p0).cross(p2 - p0);
            if (product == 0.f)
            {
                // p0 is on the edge p1-p2. We cannot determine shape orientation yet, so continue.
                continue;
            }
            return product > 0.f;
        }
        return true;
    }();

    std::size_t outlineIndex = 0;
    for (std::size_t i = 0; i < count; ++i)
    {
        const std::size_t index = i + 1;

        // Get the two segments shared by the current point
        const Vector2f p0 = (i == 0) ? m_vertices[count].position : m_vertices[index - 1].position;
        const Vector2f p1 = m_vertices[index].position;
        const Vector2f p2 = m_vertices[index + 1].position;

        // Compute their direction
        const Vector2f d1 = computeDirection(p0, p1);
        const Vector2f d2 = computeDirection(p1, p2);

        // Compute their normal pointing towards the outside of the shape
        const Vector2f n1 = flipNormals ? -d1.perpendicular() : d1.perpendicular();
        const Vector2f n2 = flipNormals ? -d2.perpendicular() : d2.perpendicular();

        // Decide whether to add a bevel or not
        const float twoCos2            = 1.f + n1.dot(n2);
        const float squaredLengthRatio = m_miterLimit * m_miterLimit * twoCos2 / 2.f;
        const bool  isConvexCorner     = d1.dot(n2) * m_outlineThickness >= 0.f;
        const bool  needsBevel         = twoCos2 == 0.f || (squaredLengthRatio < 1.f && isConvexCorner);