Calculating the winding and normal when programatically adding triangles to a mesh

Question

I'm writing a program that takes a 2D planar polygon and extrudes it to a 3D mesh with a given height. I identify triangle edges that are borders of the polygon and now I'm trying to automatically compute the two triangles required for the extrusion of the border. However, I'm stuck at how to compute the correct winding and normals

My start situation is this: I have the two coordinates of the edge (marked in white) and the normal of the original triangle (marked in orange)

Using this information I'm trying to compute two triangles which should result in:

The 4 vertices are easy to compute (just the two vertices of the edge and two more at a different height). The normal should be perpendicular to the original normal but to do that I need a second reference point. It doesn't seem to be as simple as using the centroid of the triangle.

The triangle winding confuses me. I need a counter-clockwise winding and I guess I could determine which vertices to use based on the normal but how is not immediately apparent to me.

Answer 1

I don't completely understand the problem you're having, but this is a sketch of an extrusion algorithm

Supposing polygon is an array of 3D points in counter-clockwise order (I guess they don't have to be convex, or even coplanar), and direction is a 3D vector determining the direction in which you want to extrude your polygon, this is what I came up with (in no particular language)

function extrude(polygon, direction)
    triangles = []
    -- Top cap
    for p = 0 to count(polygon) - 2 do
        p0 = polygon[0] + direction
        p1 = polygon[p + 1] + direction
        p2 = polygon[p + 2] + direction
        normal = normalize(cross(p1 - p0, p2 - p0))
        triangles.push(new triangle(p0, p1, p2, normal))
    end

    -- Bottom cap
    for p = 0 to count(polygon) - 2 do
        p0 = polygon[0]
        p1 = polygon[p + 2] -- pointing down now...
        p2 = polygon[p + 1]
        normal = normalize(cross(p1 - p0, p2 - p0))
        triangles.push(new triangle(p0, p1, p2, normal))
    end

    -- Sides
    for p = 0 to count(polygon) do
        p0 = polygon[p]
        p1 = polygon[(p + 1) mod count(polygon)]
        p2 = p0 + direction
        p3 = p1 + direction
        normal = normalize(cross(p1 - p0, p2 - p0))
        triangles.push(new triangle(p0, p1, p2, normal))
        triangles.push(new triangle(p0, p2, p3, normal))
    end

    return triangles
end

The normals created by this snippet point outwards for each face. You could also average them with the normal of the adjacent face to create a softer look for polygons with lots of faces...

Would something like this work for you?