generate_grid()

MAYAFLUX_API Kakshya::MeshData MayaFlux::Kinesis::generate_grid	(	const glm::vec3 &	center,
		float	extent_x,
		float	extent_z,
		uint32_t	cols,
		uint32_t	rows,
		const glm::vec3 &	normal = glm::vec3(0.0F, 1.0F, 0.0F)
	)

Generate a subdivided flat grid in the XZ plane.

Vertices lie at Y = 0. U maps to X, V maps to Z. UV covers [0,1] across the full extent. Normals point along +Y throughout.

Parameters

center	World-space centre of the grid.
extent_x	Total width along X.
extent_z	Total depth along Z.
cols	Number of columns (cells along X). Clamped to minimum 1.
rows	Number of rows (cells along Z). Clamped to minimum 1.

Returns

MeshData ready for TRIANGLE_LIST draw.

Definition at line 892 of file GeometryPrimitives.cpp.

{
    cols = std::max(cols, 1U);
    rows = std::max(rows, 1U);
 
    const glm::vec3 n = glm::normalize(normal);
    glm::vec3 u;
    if (std::abs(n.y) < 0.9F) {
        u = glm::normalize(glm::cross(n, glm::vec3(0.0F, 1.0F, 0.0F)));
    } else {
        u = glm::normalize(glm::cross(n, glm::vec3(1.0F, 0.0F, 0.0F)));
    }
    const glm::vec3 v = glm::normalize(glm::cross(u, n));
 
    const float half_x = extent_x * 0.5F;
    const float half_z = extent_z * 0.5F;
 
    std::vector<Kakshya::MeshVertex> verts;
    std::vector<uint32_t> indices;
    verts.reserve(uint32_t(2 * (cols + 1) * (rows + 1)));
    indices.reserve(uint32_t(2 * cols * rows * 6));
 
    for (uint32_t row = 0; row <= rows; ++row) {
        const float fv = static_cast<float>(row) / static_cast<float>(rows);
        for (uint32_t col = 0; col <= cols; ++col) {
            const float fu = static_cast<float>(col) / static_cast<float>(cols);
            const glm::vec3 p = center
                + u * glm::mix(-half_x, half_x, fu)
                + v * glm::mix(-half_z, half_z, fv);
            verts.push_back({
                .position = p,
                .uv = { fu, 1.0F - fv },
                .normal = n,
            });
        }
    }
 
    const uint32_t stride = cols + 1;
    const auto vert_count = static_cast<uint32_t>(verts.size());
 
    for (uint32_t row = 0; row < rows; ++row) {
        for (uint32_t col = 0; col < cols; ++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 });
        }
    }
 
    for (uint32_t row = 0; row <= rows; ++row) {
        const float fv = static_cast<float>(row) / static_cast<float>(rows);
        for (uint32_t col = 0; col <= cols; ++col) {
            const float fu = static_cast<float>(col) / static_cast<float>(cols);
            const glm::vec3 p = center
                + u * glm::mix(-half_x, half_x, fu)
                + v * glm::mix(-half_z, half_z, fv);
            verts.push_back({
                .position = p,
                .uv = { fu, 1.0F - fv },
                .normal = -n,
            });
        }
    }
 
    for (uint32_t row = 0; row < rows; ++row) {
        for (uint32_t col = 0; col < cols; ++col) {
            const uint32_t a = vert_count + 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, c, b, b, c, d });
        }
    }
 
    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_grid(), indices, MayaFlux::Kakshya::MeshInsertion::insert_flat(), and rows.

Referenced by generate_grid().

Here is the call graph for this function:

Here is the caller graph for this function: