generate_explicit_surface()

MAYAFLUX_API Kakshya::MeshData MayaFlux::Kinesis::generate_explicit_surface	(	std::span< const float >	heights,
		uint32_t	columns,
		uint32_t	rows,
		const glm::vec2 &	extent,
		float	height_scale = 1.0F,
		const glm::vec3 &	center = glm::vec3(0.0F)
	)

Generate a mesh from the graph of a function sampled on a grid, y = f(x, z).

heights holds one value per grid point, row-major, columns values along X for each of rows steps along Z. The surface is centred on center and spans extent in X and Z. Normals and tangents come from central differences of the heights, so they follow the surface and are never degenerate. The raw height is stored in each vertex's weight. UV runs (0, 1) at the first row and first column.

Use it where the data is already a table of values: a sound's recent blocks, an image's brightness, a spectrogram, a column of a file. The triangle indices depend only on the grid size and are reused between calls, so regenerating every frame costs one pass over the heights; large grids are filled in parallel.

Parameters

heights	columns * rows values.
columns	Grid points along X. Minimum 2.
rows	Grid points along Z. Minimum 2.
extent	World size in X and Z.
height_scale	Multiplier from a height to a world Y offset.
center	World position of the middle of the grid at zero height.

Returns

MeshData ready for TRIANGLE_LIST draw, empty and logged if the sizes disagree.

Definition at line 1042 of file GeometryPrimitives.cpp.

{
    if (columns < 2 || rows < 2 || heights.size() != static_cast<size_t>(columns) * rows) {
        MF_ERROR(Journal::Component::Kinesis, Journal::Context::Runtime,
            "generate_explicit_surface needs at least 2 columns and rows and exactly columns * rows heights, got {} heights for {} by {}",
            heights.size(), columns, rows);
        return Kakshya::MeshData::empty();
    }
 
    constexpr size_t stride = sizeof(Kakshya::MeshVertex);
    const size_t vertex_count = static_cast<size_t>(columns) * rows;
 
    const float inv_columns = 1.0F / static_cast<float>(columns - 1);
    const float inv_rows = 1.0F / static_cast<float>(rows - 1);
    const float dx = std::max(extent.x, 1e-6F) * inv_columns;
    const float dz = std::max(extent.y, 1e-6F) * inv_rows;
    const float x0 = center.x - 0.5F * dx * static_cast<float>(columns - 1);
    const float z0 = center.z - 0.5F * dz * static_cast<float>(rows - 1);
 
    std::vector<uint8_t> bytes(vertex_count * stride);
    uint8_t* const out = bytes.data();
    const float* const h = heights.data();
 
    const auto fill_row = [&](size_t row) {
        const size_t row_prev = row > 0 ? row - 1 : row;
        const size_t row_next = row + 1 < rows ? row + 1 : row;
        const float inv_span_z = 1.0F / (static_cast<float>(row_next - row_prev) * dz);
 
        const float* h_row = h + row * columns;
        const float* h_prev = h + row_prev * columns;
        const float* h_next = h + row_next * columns;
 
        for (size_t col = 0; col < columns; ++col) {
            const size_t col_prev = col > 0 ? col - 1 : col;
            const size_t col_next = col + 1 < columns ? col + 1 : col;
 
            const float slope_x = (h_row[col_next] - h_row[col_prev]) * height_scale
                / (static_cast<float>(col_next - col_prev) * dx);
            const float slope_z = (h_next[col] - h_prev[col]) * height_scale * inv_span_z;
 
            const float normal_scale = glm::inversesqrt(1.0F + slope_x * slope_x + slope_z * slope_z);
            const float tangent_scale = glm::inversesqrt(1.0F + slope_x * slope_x);
 
            Kakshya::MeshVertex vertex;
            vertex.position = { x0 + static_cast<float>(col) * dx,
                center.y + h_row[col] * height_scale,
                z0 + static_cast<float>(row) * dz };
            vertex.weight = h_row[col];
            vertex.uv = { static_cast<float>(col) * inv_columns, 1.0F - static_cast<float>(row) * inv_rows };
            vertex.normal = { -slope_x * normal_scale, normal_scale, -slope_z * normal_scale };
            vertex.tangent = { tangent_scale, slope_x * tangent_scale, 0.0F };
 
            std::memcpy(out + (row * columns + col) * stride, &vertex, stride);
        }
    };
 
    if (vertex_count >= k_parallel_vertex_threshold) {
        std::vector<size_t> row_ids(rows);
        std::iota(row_ids.begin(), row_ids.end(), size_t { 0 });
        std::for_each(std::execution::par_unseq, row_ids.begin(), row_ids.end(), fill_row);
    } else {
        for (size_t row = 0; row < rows; ++row) {
            fill_row(row);
        }
    }
 
    auto data = Kakshya::MeshData::empty();
    data.vertex_variant = std::move(bytes);
    data.index_variant = surface_indices(columns, rows);
    data.layout = Kakshya::VertexLayout::for_meshes(stride);
    data.layout.vertex_count = static_cast<uint32_t>(vertex_count);
    return data;
}

References columns, generate_explicit_surface(), h, MF_ERROR, MayaFlux::Kakshya::MeshVertex::normal, out, MayaFlux::Kakshya::MeshVertex::position, rows, MayaFlux::Kakshya::MeshVertex::tangent, MayaFlux::Kakshya::MeshVertex::uv, and MayaFlux::Kakshya::MeshVertex::weight.

Referenced by generate_explicit_surface().

Here is the call graph for this function:

Here is the caller graph for this function: