generate_box()

MAYAFLUX_API Kakshya::MeshData MayaFlux::Kinesis::generate_box	(	const glm::vec3 &	center,
		const glm::vec3 &	half_extents,
		uint32_t	subdivisions = 1
	)

Generate a solid box as an indexed TRIANGLE_LIST mesh.

Six faces, four vertices each, two triangles per face. Per-face normals point outward along the face axis. UV origin is bottom-left matching Vulkan image layout and the generate_quad convention.

Parameters

center	Centre of the box in world space.
half_extents	Half-size along each axis. Non-uniform values yield a cuboid.
subdivisions	Reserved for future per-face tessellation. Currently ignored.

Returns

MeshData ready for MeshBuffer::set_mesh_data() or MeshWriterNode::set_mesh().

Definition at line 824 of file GeometryPrimitives.cpp.

{
    const uint32_t n = std::max(subdivisions, 1U);
 
    std::vector<Kakshya::MeshVertex> verts;
    std::vector<uint32_t> indices;
    verts.reserve(uint32_t(6 * (n + 1) * (n + 1)));
    indices.reserve(uint32_t(6 * n * n * 6));
 
    struct FaceDef {
        glm::vec3 origin;
        glm::vec3 u_axis;
        glm::vec3 v_axis;
        glm::vec3 normal;
    };
 
    const std::array<FaceDef, 6> faces = { {
        { .origin = { -1, -1, 1 }, .u_axis = { 2, 0, 0 }, .v_axis = { 0, 2, 0 }, .normal = { 0, 0, 1 } },
        { .origin = { 1, -1, -1 }, .u_axis = { -2, 0, 0 }, .v_axis = { 0, 2, 0 }, .normal = { 0, 0, -1 } },
        { .origin = { 1, -1, 1 }, .u_axis = { 0, 0, -2 }, .v_axis = { 0, 2, 0 }, .normal = { 1, 0, 0 } },
        { .origin = { -1, -1, -1 }, .u_axis = { 0, 0, 2 }, .v_axis = { 0, 2, 0 }, .normal = { -1, 0, 0 } },
        { .origin = { -1, 1, 1 }, .u_axis = { 2, 0, 0 }, .v_axis = { 0, 0, -2 }, .normal = { 0, 1, 0 } },
        { .origin = { -1, -1, -1 }, .u_axis = { 2, 0, 0 }, .v_axis = { 0, 0, 2 }, .normal = { 0, -1, 0 } },
    } };
 
    for (const auto& f : faces) {
        const auto base = static_cast<uint32_t>(verts.size());
 
        for (uint32_t row = 0; row <= n; ++row) {
            const float fv = static_cast<float>(row) / static_cast<float>(n);
            for (uint32_t col = 0; col <= n; ++col) {
                const float fu = static_cast<float>(col) / static_cast<float>(n);
                const glm::vec3 p = f.origin + f.u_axis * fu + f.v_axis * fv;
                verts.push_back({
                    .position = center + p * half_extents,
                    .uv = { fu, 1.0F - fv },
                    .normal = f.normal,
                });
            }
        }
 
        const uint32_t stride = n + 1;
        for (uint32_t row = 0; row < n; ++row) {
            for (uint32_t col = 0; col < n; ++col) {
                const uint32_t a = base + 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, d, a, 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_box(), indices, and MayaFlux::Kakshya::MeshInsertion::insert_flat().

Referenced by generate_box().

Here is the call graph for this function:

Here is the caller graph for this function: