view()

template<typename T >

auto MayaFlux::Kakshya::DataAccess::view

(

)

const

Get explicit typed view of data.

Template Parameters

T	View type (glm::vec3, double, float, etc.)

Returns

Span-like view of data as type T

Note

If type conversion is needed, the view remains valid for the lifetime of this DataAccess object. Multiple calls with the same type reuse the cached conversion.

Definition at line 269 of file DataAccess.hpp.

{
    if constexpr (GlmType<T>) {
        validate_structured_access<T>();
 
        return std::visit([&](auto& vec) -> StructuredView<T> {
            using StorageType = typename std::decay_t<decltype(vec)>::value_type;
            using ComponentType = glm_component_type<T>;
            constexpr size_t components = glm_component_count<T>();
 
            size_t required_components = m_dimensions[0].size * components;
            if (vec.size() < required_components) {
                error<std::runtime_error>(
                    Journal::Component::Kakshya,
                    Journal::Context::Runtime,
                    std::source_location::current(),
                    "Insufficient data: need {} elements of type {} but have {} elements of type {}",
                    m_dimensions[0].size,
                    typeid(T).name(),
                    vec.size() / components,
                    typeid(StorageType).name());
            }
 
            if constexpr (std::is_same_v<StorageType, ComponentType>) {
                return StructuredView<T>(vec.data(), m_dimensions[0].size);
            } else if constexpr (std::is_convertible_v<StorageType, ComponentType>) {
                size_t required_bytes = vec.size() * sizeof(ComponentType);
                void* cache_ptr = ensure_conversion_cache<ComponentType>(required_bytes);
 
                ComponentType* cache_data = static_cast<ComponentType*>(cache_ptr);
                std::ranges::transform(vec, cache_data,
                    [](auto val) { return static_cast<ComponentType>(val); });
 
                return StructuredView<T>(cache_data, m_dimensions[0].size);
            } else {
                error<std::invalid_argument>(
                    Journal::Component::Kakshya,
                    Journal::Context::Runtime,
                    std::source_location::current(),
                    "Cannot convert storage type {} to component type {}",
                    typeid(StorageType).name(),
                    typeid(ComponentType).name());
            }
        },
            m_variant);
 
    } else if constexpr (std::is_arithmetic_v<T>) {
        return create_scalar_view<T>();
 
    } else {
        static_assert(always_false_v<T>,
            "Unsupported view type. Use glm types or arithmetic types (double, float, int, etc.)");
    }
}

References MayaFlux::Journal::Kakshya, m_dimensions, m_variant, and MayaFlux::Journal::Runtime.

Referenced by MayaFlux::Buffers::download_audio_from_gpu(), MayaFlux::Buffers::upload_from_view(), and MayaFlux::Buffers::upload_structured_view().

Here is the caller graph for this function: