apply_color_gradient()

std::vector< Nodes::LineVertex > MayaFlux::Kinesis::apply_color_gradient	(	const std::vector< glm::vec3 > &	positions,
		const std::vector< glm::vec3 > &	colors,
		const std::vector< float > &	color_positions = {},
		float	default_thickness = 1.0F
	)

Apply color interpolation to position vertices.

Parameters

positions	Input position vertices
colors	Color stops for interpolation
color_positions	Normalized positions [0,1] for each color stop
default_thickness	Line thickness for all vertices (default: 1.0)

Returns

LineVertex array with interpolated colors

Example: colors = {red, blue} color_positions = {0.0, 1.0} → Linear gradient from red to blue along path

If color_positions.empty(), distributes colors uniformly.

Definition at line 568 of file GeometryPrimitives.cpp.

{
    if (positions.empty() || colors.empty()) {
        return {};
    }
 
    std::vector<Nodes::LineVertex> vertices;
    vertices.reserve(positions.size());
 
    if (colors.size() == 1) {
        for (const auto& pos : positions) {
            vertices.push_back({ .position = pos,
                .color = colors[0],
                .thickness = default_thickness });
        }
        return vertices;
    }
 
    std::vector<float> stops = color_positions;
    if (stops.empty()) {
        stops.reserve(colors.size());
        for (size_t i = 0; i < colors.size(); ++i) {
            stops.push_back(static_cast<float>(i) / static_cast<float>(colors.size() - 1));
        }
    }
 
    for (size_t i = 0; i < positions.size(); ++i) {
        float t = static_cast<float>(i) / static_cast<float>(positions.size() - 1);
 
        glm::vec3 color;
        if (t <= stops[0]) {
            color = colors[0];
        } else if (t >= stops.back()) {
            color = colors.back();
        } else {
            size_t idx = 0;
            for (size_t j = 1; j < stops.size(); ++j) {
                if (t <= stops[j]) {
                    idx = j - 1;
                    break;
                }
            }
 
            float local_t = (t - stops[idx]) / (stops[idx + 1] - stops[idx]);
            color = glm::mix(colors[idx], colors[idx + 1], local_t);
        }
 
        vertices.push_back({ .position = positions[i],
            .color = color,
            .thickness = default_thickness });
    }
 
    return vertices;
}

References apply_color_gradient(), and color.

Referenced by apply_color_gradient().

Here is the call graph for this function:

Here is the caller graph for this function: