capture_volume()

uint32_t MayaFlux::IO::IOManager::capture_volume	(	const std::shared_ptr< Buffers::VolumeGridBuffer > &	volume,
		const std::string &	path_pattern,
		const std::vector< std::string > &	field_names = {},
		const IO::VolumeWriteOptions &	options = {},
		uint32_t	max_frames = 0,
		uint64_t	frame_interval = 1
	)

Begin recording a numbered .vdb sequence from a volume.

Constructs a VolumeCapture on the engine scheduler and retains it. The capture spawns a GraphicsRoutine that reads one frame and suspends on a FrameDelay, so it advances on the frame clock and resumes on the thread that has command queue access. Nothing polls it and nothing drives it.

The readback stays on the graphics thread because it must. The encode is dispatched to the save task pool, so the per-frame cost on the graphics thread is the transfer alone.

For a capture the caller owns and drives itself, construct IO::VolumeCapture directly.

Parameters

volume	Volume to record.
path_pattern	Destination with one index field, such as "smoke.{:04}.vdb". Zero padding matters.
field_names	Fields to record. Empty means all.
options	Writer options, applied to every frame.
max_frames	Stop after this many frames. Zero is unbounded.
frame_interval	Frames between captures.

Returns

Capture handle for stop_volume_capture, or 0 on failure.

Definition at line 1356 of file IOManager.cpp.

{
    if (!volume) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "capture_volume: null volume");
        return 0;
    }
 
    if (!m_scheduler) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "capture_volume: TaskScheduler unavailable");
        return 0;
    }
 
    auto capture = Detail::create_volume_capture(
        *m_scheduler, volume, path_pattern, field_names, options,
        [this](Kakshya::VolumeData&& data,
            const std::string& path,
            const IO::VolumeWriteOptions& opts) {
            return save_volume(std::move(data), path, opts);
        },
        max_frames, frame_interval);
 
    const uint32_t id = m_next_volume_capture_id.fetch_add(1, std::memory_order_relaxed);
 
    std::lock_guard lock(m_volume_captures_mutex);
    m_volume_captures.emplace(id, std::move(capture));
    return id;
}

References MayaFlux::IO::Detail::create_volume_capture(), MayaFlux::Journal::FileIO, MayaFlux::Journal::IO, m_next_volume_capture_id, m_scheduler, m_volume_captures, m_volume_captures_mutex, MF_ERROR, and save_volume().

Here is the call graph for this function: