extract_inputs()

template<ComputeData InputType = std::vector<Kakshya::DataVariant>, ComputeData OutputType = InputType>

virtual std::pair< std::vector< std::vector< double > >, DataStructureInfo > MayaFlux::Yantra::GpuExecutionContext< InputType, OutputType >::extract_inputs ( const input_type &  input )

inlineprotectedvirtual

Extract channel data and structure metadata from the input Datum.

Calls extract_structured_native first to obtain native-typed spans without any conversion, then resolves the native element type from the first span's active DataSpanVariant alternative (which is already determined by visiting the source variants – no separate original_type inspection needed).

• float / uint8_t / uint16_t / uint32_t: stages raw bytes natively via flatten_native_variants_to_staging. Returns ({}, structure_info).
• double / complex / anything else: converts spans to vector<vector<double>> for the standard double staging path. Unchanged from previous behaviour.

Override to return ({}, {}) when channel extraction is not needed (e.g. image-only shaders that stage via on_before_gpu_dispatch).

Reimplemented in MayaFlux::Yantra::TextureExecutionContext.

Definition at line 120 of file GpuExecutionContext.hpp.

    {
        auto info = OperationHelper::get_structure_info(const_cast<input_type&>(input));
 
        const std::type_index native_type = [&]() -> std::type_index {
            if constexpr (std::is_same_v<
                              std::decay_t<decltype(input.data)>,
                              std::shared_ptr<Kakshya::SignalSourceContainer>>) {
                if (input.data)
                    return input.data->value_element_type();
            } else if constexpr (std::is_same_v<
                                     std::decay_t<decltype(input.data)>,
                                     std::vector<Kakshya::DataVariant>>) {
                if (!input.data.empty())
                    return Kakshya::FrameView(OperationHelper::extract_native_data(input.data[0])).element_type();
            }
            return typeid(double);
        }();
 
        const bool is_native_non_double = native_type == typeid(float) || native_type == typeid(uint8_t) || native_type == typeid(uint16_t) || native_type == typeid(uint32_t);
 
        if (is_native_non_double) {
            if constexpr (std::is_same_v<
                              std::decay_t<decltype(input.data)>,
                              std::vector<Kakshya::DataVariant>>) {
                flatten_native_variants_to_staging(input.data, info);
            } else if constexpr (std::is_same_v<
                                     std::decay_t<decltype(input.data)>,
                                     std::shared_ptr<Kakshya::SignalSourceContainer>>) {
                flatten_native_variants_to_staging(input.data->get_data(), info);
            }
            return { {}, std::move(info) };
        }
 
        auto [spans, double_info] = OperationHelper::extract_structured_double(
            const_cast<input_type&>(input));
 
        std::vector<std::vector<double>> channels(spans.size());
        for (size_t c = 0; c < spans.size(); ++c)
            channels[c].assign(spans[c].begin(), spans[c].end());
        return { std::move(channels), std::move(double_info) };
    }

References channels, MayaFlux::Yantra::OperationHelper::extract_native_data(), MayaFlux::Yantra::OperationHelper::extract_structured_double(), MayaFlux::Yantra::GpuDispatchCore::flatten_native_variants_to_staging(), MayaFlux::Yantra::OperationHelper::get_structure_info(), and input.

Referenced by MayaFlux::Yantra::ShaderExecutionContext< InputType, OutputType >::dispatch_async(), and MayaFlux::Yantra::GpuExecutionContext< InputType, OutputType >::execute().

Here is the call graph for this function:

Here is the caller graph for this function: