compute_path_normals()

std::vector< Nodes::LineVertex > MayaFlux::Kinesis::compute_path_normals	(	const std::vector< Nodes::LineVertex > &	path_vertices,
		float	normal_length,
		size_t	stride = 1
	)

Compute normal vectors along a piecewise-linear path.

Parameters

path_vertices	Sequential vertices defining curve
normal_length	Magnitude of normal vectors
stride	Sample every stride-th vertex (default: 1)

Returns

Line segments (pairs) representing normals (for LINE_LIST topology)

Normal at vertex i: perpendicular to tangent (v[i+1] - v[i]) Returned as pairs: [midpoint - normal/2, midpoint + normal/2]

Definition at line 235 of file GeometryPrimitives.cpp.

{
    if (path_vertices.size() < 2 || stride == 0) {
        return {};
    }
 
    std::vector<Nodes::LineVertex> normals;
    normals.reserve((path_vertices.size() - 1) / stride * 2);
 
    for (size_t i = 0; i < path_vertices.size() - 1; i += stride) {
        glm::vec3 p0 = path_vertices[i].position;
        glm::vec3 p1 = path_vertices[i + 1].position;
 
        glm::vec3 tangent = p1 - p0;
        float length = glm::length(tangent);
 
        if (length < 1e-6F) {
            continue;
        }
 
        tangent /= length;
 
        // Normal (perpendicular in XY plane)
        // For 2D: rotate tangent 90° counter-clockwise
        glm::vec3 normal(-tangent.y, tangent.x, 0.0F);
        normal = glm::normalize(normal) * normal_length;
 
        glm::vec3 midpoint = (p0 + p1) * 0.5F;
 
        glm::vec3 color = path_vertices[i].color;
        float thickness = path_vertices[i].thickness;
 
        normals.push_back({ .position = midpoint - normal * 0.5F,
            .color = color,
            .thickness = thickness });
 
        normals.push_back({ .position = midpoint + normal * 0.5F,
            .color = color,
            .thickness = thickness });
    }
 
    return normals;
}