generate_parametric_surface() [2/2]

Kakshya::MeshData MayaFlux::Kinesis::generate_parametric_surface	(	const std::function< glm::vec3(float, float)> &	fn,
		uint32_t	u_segs,
		uint32_t	v_segs
	)

Definition at line 910 of file GeometryPrimitives.cpp.

{
    u_segs = std::max(u_segs, 1U);
    v_segs = std::max(v_segs, 1U);
 
    std::vector<Kakshya::MeshVertex> verts;
    std::vector<uint32_t> indices;
    verts.reserve(uint32_t((u_segs + 1) * (v_segs + 1)));
    indices.reserve(uint32_t(u_segs * v_segs * 6));
 
    constexpr float eps = 1e-4F;
 
    for (uint32_t row = 0; row <= v_segs; ++row) {
        const float fv = static_cast<float>(row) / static_cast<float>(v_segs);
        for (uint32_t col = 0; col <= u_segs; ++col) {
            const float fu = static_cast<float>(col) / static_cast<float>(u_segs);
 
            const glm::vec3 p = fn(fu, fv);
            const glm::vec3 pu = fn(fu + eps, fv) - fn(fu - eps, fv);
            const glm::vec3 pv = fn(fu, fv + eps) - fn(fu, fv - eps);
            const glm::vec3 n = glm::normalize(glm::cross(pu, pv));
 
            verts.push_back({
                .position = p,
                .uv = { fu, 1.0F - fv },
                .normal = n,
            });
        }
    }
 
    const uint32_t stride = u_segs + 1;
    for (uint32_t row = 0; row < v_segs; ++row) {
        for (uint32_t col = 0; col < u_segs; ++col) {
            const uint32_t a = row * stride + col;
            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_parametric_surface(), and MayaFlux::Kakshya::MeshInsertion::insert_flat().

Referenced by generate_parametric_surface().

Here is the call graph for this function:

Here is the caller graph for this function: