generate_tube() [2/2]

Kakshya::MeshData MayaFlux::Kinesis::generate_tube	(	std::span< const glm::vec3 >	path,
		const std::function< float(float)> &	radius_fn,
		uint32_t	radial_segments,
		bool	capped
	)

Definition at line 966 of file GeometryPrimitives.cpp.

{
    const uint32_t seg = std::max(radial_segments, 3U);
    const auto n_pts = static_cast<uint32_t>(std::max<size_t>(path.size(), 2));
 
    std::vector<Kakshya::MeshVertex> verts;
    std::vector<uint32_t> indices;
    verts.reserve(uint32_t(n_pts * (seg + 1) + (capped ? 2 * (seg + 1) : 0)));
    indices.reserve(uint32_t((n_pts - 1) * seg * 6 + (capped ? 2 * seg * 3 : 0)));
 
    glm::vec3 tangent = glm::normalize(path[1] - path[0]);
    glm::vec3 u_axis;
    if (std::abs(tangent.y) < 0.9F) {
        u_axis = glm::normalize(glm::cross(tangent, glm::vec3(0.0F, 1.0F, 0.0F)));
    } else {
        u_axis = glm::normalize(glm::cross(tangent, glm::vec3(1.0F, 0.0F, 0.0F)));
    }
 
    glm::vec3 v_axis = glm::normalize(glm::cross(tangent, u_axis));
 
    const float total_len = [&]() {
        float l = 0.0F;
        for (uint32_t i = 1; i < n_pts; ++i)
            l += glm::distance(path[i], path[i - 1]);
        return l;
    }();
 
    float arc = 0.0F;
 
    for (uint32_t pi = 0; pi < n_pts; ++pi) {
        if (pi > 0) {
            const glm::vec3 new_tan = (pi + 1 < n_pts)
                ? glm::normalize(path[pi + 1] - path[pi - 1])
                : glm::normalize(path[pi] - path[pi - 1]);
            const glm::vec3 axis = glm::cross(tangent, new_tan);
            const float axis_len = glm::length(axis);
            if (axis_len > 1e-6F) {
                const float angle = std::asin(glm::clamp(axis_len, 0.0F, 1.0F));
                const glm::mat4 rot = glm::rotate(glm::mat4(1.0F), angle,
                    glm::normalize(axis));
                u_axis = glm::vec3(rot * glm::vec4(u_axis, 0.0F));
                v_axis = glm::vec3(rot * glm::vec4(v_axis, 0.0F));
                tangent = new_tan;
            }
            arc += glm::distance(path[pi], path[pi - 1]);
        }
 
        const float t = (total_len > 1e-6F) ? (arc / total_len) : 0.0F;
        const float r = radius_fn(t);
        const float angle_step = glm::two_pi<float>() / static_cast<float>(seg);
 
        for (uint32_t s = 0; s <= seg; ++s) {
            const float a = static_cast<float>(s) * angle_step;
            const float ca = std::cos(a);
            const float sa = std::sin(a);
            const glm::vec3 radial = ca * u_axis + sa * v_axis;
            verts.push_back({
                .position = path[pi] + radial * r,
                .uv = { static_cast<float>(s) / static_cast<float>(seg), t },
                .normal = radial,
            });
        }
    }
 
    const uint32_t ring = seg + 1;
    for (uint32_t pi = 0; pi < n_pts - 1; ++pi) {
        for (uint32_t s = 0; s < seg; ++s) {
            const uint32_t a = pi * ring + s;
            const uint32_t b = a + 1;
            const uint32_t c = a + ring;
            const uint32_t d = c + 1;
            indices.insert(indices.end(), { a, b, c, b, d, c });
        }
    }
 
    if (capped) {
        for (int end = 0; end < 2; ++end) {
            const uint32_t ring_base = (end == 0) ? 0 : (n_pts - 1) * ring;
            const float t_cap = (end == 0) ? 0.0F : 1.0F;
            const glm::vec3 cap_nrm = (end == 0) ? -tangent : tangent;
            const glm::vec3 cap_pos = path[(end == 0) ? 0 : n_pts - 1];
 
            const auto centre_idx = static_cast<uint32_t>(verts.size());
            verts.push_back({
                .position = cap_pos,
                .uv = { 0.5F, t_cap },
                .normal = cap_nrm,
            });
 
            for (uint32_t s = 0; s < seg; ++s) {
                const uint32_t a = ring_base + s;
                const uint32_t b = ring_base + s + 1;
                if (end == 0) {
                    indices.insert(indices.end(), { centre_idx, b, a });
                } else {
                    indices.insert(indices.end(), { centre_idx, a, b });
                }
            }
        }
    }
 
    auto data = Kakshya::MeshData::empty();
    Kakshya::MeshInsertion ins(data.vertex_variant, data.index_variant);
    ins.insert_flat(
        std::span<const uint8_t>(reinterpret_cast<const uint8_t*>(verts.data()),
            verts.size() * sizeof(Kakshya::MeshVertex)),
        std::span<const uint32_t>(indices),
        Kakshya::VertexLayout::for_meshes(sizeof(Kakshya::MeshVertex)));
    data.layout = Kakshya::VertexLayout::for_meshes(sizeof(Kakshya::MeshVertex));
    data.layout.vertex_count = static_cast<uint32_t>(verts.size());
    return data;
}

References a, b, generate_tube(), and MayaFlux::Kakshya::MeshInsertion::insert_flat().

Referenced by generate_tube().

Here is the call graph for this function:

Here is the caller graph for this function: