generate_revolution() [2/2]

Kakshya::MeshData MayaFlux::Kinesis::generate_revolution	(	const std::function< glm::vec2(float)> &	profile_fn,
		uint32_t	profile_segs,
		uint32_t	radial_segs,
		float	sweep_radians
	)

Definition at line 1252 of file GeometryPrimitives.cpp.

{
    profile_segs = std::max(profile_segs, 2U);
    radial_segs = std::max(radial_segs, 3U);
 
    std::vector<Kakshya::MeshVertex> verts;
    std::vector<uint32_t> indices;
    verts.reserve(size_t((profile_segs + 1)) * (radial_segs + 1));
    indices.reserve(uint32_t(profile_segs * radial_segs * 6));
 
    for (uint32_t pi = 0; pi <= profile_segs; ++pi) {
        const float t = static_cast<float>(pi) / static_cast<float>(profile_segs);
        const glm::vec2 p = profile_fn(t); // p.x = radius from Y axis, p.y = height
 
        for (uint32_t ri = 0; ri <= radial_segs; ++ri) {
            const float u = static_cast<float>(ri) / static_cast<float>(radial_segs);
            const float angle = u * sweep_radians;
            const float ca = std::cos(angle);
            const float sa = std::sin(angle);
 
            const glm::vec3 pos { p.x * ca, p.y, p.x * sa };
 
            constexpr float eps = 1e-4F;
            const glm::vec2 dp = profile_fn(glm::clamp(t + eps, 0.0F, 1.0F))
                - profile_fn(glm::clamp(t - eps, 0.0F, 1.0F));
            const glm::vec3 profile_tan { dp.x * ca, dp.y, dp.x * sa };
            const glm::vec3 radial { ca, 0.0F, sa };
            const glm::vec3 nrm = glm::normalize(glm::cross(profile_tan, radial));
 
            verts.push_back({
                .position = pos,
                .uv = { u, 1.0F - t },
                .normal = nrm,
            });
        }
    }
 
    const uint32_t stride = radial_segs + 1;
    for (uint32_t pi = 0; pi < profile_segs; ++pi) {
        for (uint32_t ri = 0; ri < radial_segs; ++ri) {
            const uint32_t a = pi * stride + ri;
            const uint32_t b = a + 1;
            const uint32_t c = a + stride;
            const uint32_t d = c + 1;
            indices.insert(indices.end(), { a, b, c, b, d, c });
        }
    }
 
    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_revolution(), indices, and MayaFlux::Kakshya::MeshInsertion::insert_flat().

Referenced by generate_revolution().

Here is the call graph for this function:

Here is the caller graph for this function: