upload_volume()

bool MayaFlux::IO::upload_volume	(	const Kakshya::VolumeData &	data,
		const std::shared_ptr< Buffers::VolumeGridBuffer > &	volume
	)

Upload every field of a host VolumeData into a GPU-resident volume.

The reverse of download_volume: for each field in data whose name is declared on volume, writes its bytes into the current write slot via VolumeGridBuffer::seed_raw. The calling thread must have command queue access, matching download_volume's requirement, since seed_raw records a transfer that must resolve before the next one can be issued.

A scalar field (VolumeField holding vector<float>) uploads directly. A vector field is expanded from glm::vec3 to glm::vec4 first, zeroing the fourth component, because the GPU layout carries that padding and VolumeData does not — the inverse of the gather download_volume performs. That expansion costs an allocation at four thirds the input size.

A field named in data but not declared on volume, or whose declared stride does not match what the field's variant implies (float for a scalar, vec4 for a vector), is skipped with an error; the rest of the upload proceeds. Neither VolumeData's lattice nor its cell count is checked against the volume's own — a mismatch surfaces as seed_raw's own size-mismatch error per field, not as a single upfront rejection.

Each field is one seed_raw call rather than a batched transfer: simpler than building a seed_raw counterpart to read_fields' batching, at the cost of one staging round trip per field instead of one for the whole upload. Worth revisiting if upload_volume becomes a per-frame path rather than the one-shot load this exists for.

Parameters

data	Source, typically from IO::VolumeReader::load().
volume	Destination. Fields must already be declared; this call never declares one.

Returns

True if at least one field was uploaded.

Definition at line 124 of file VolumeTransfer.cpp.

{
    if (!volume) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "upload_volume: null volume");
        return false;
    }
 
    if (!data.is_consistent()) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "upload_volume: VolumeData failed is_consistent()");
        return false;
    }
 
    size_t uploaded = 0;
 
    for (const auto& field : data.fields) {
        if (!volume->has_field(field.name)) {
            MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                "upload_volume: no field named '{}' on this volume, skipped", field.name);
            continue;
        }
 
        const size_t stride = volume->get_field_stride(field.name);
 
        if (const auto* scalars = field.as_scalar()) {
            if (stride != sizeof(float)) {
                MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                    "upload_volume: field '{}' has stride {}, but VolumeData holds a scalar "
                    "(expected {}), skipped",
                    field.name, stride, sizeof(float));
                continue;
            }
            volume->seed_raw(field.name, scalars->data(), scalars->size() * sizeof(float));
            ++uploaded;
            continue;
        }
 
        const auto* vectors = field.as_vector();
        if (stride != sizeof(glm::vec4)) {
            MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                "upload_volume: field '{}' has stride {}, but VolumeData holds a vector "
                "(expected {}), skipped",
                field.name, stride, sizeof(glm::vec4));
            continue;
        }
 
        std::vector<glm::vec4> padded(vectors->size());
        for (size_t i = 0; i < vectors->size(); ++i) {
            padded[i] = glm::vec4((*vectors)[i], 0.0F);
        }
        volume->seed_raw(field.name, padded.data(), padded.size() * sizeof(glm::vec4));
        ++uploaded;
    }
 
    if (uploaded == 0) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "upload_volume: no field was uploaded");
        return false;
    }
 
    MF_DEBUG(Journal::Component::IO, Journal::Context::FileIO,
        "upload_volume: {} of {} fields", uploaded, data.fields.size());
 
    return true;
}

References MayaFlux::Kakshya::VolumeData::fields, MayaFlux::Journal::FileIO, MayaFlux::Journal::IO, MayaFlux::Kakshya::VolumeData::is_consistent(), MF_DEBUG, and MF_ERROR.

Referenced by MayaFlux::IO::IOManager::load_volume().

Here is the call graph for this function:

Here is the caller graph for this function: