as_texture_access()

MAYAFLUX_API std::optional< TextureAccess > MayaFlux::Kakshya::as_texture_access

(

const DataVariant &

variant

)

Extract a TextureAccess from a DataVariant.

Parameters

variant

Source data.

Returns

Populated TextureAccess, or std::nullopt on incompatible type.

DataVariant active type → GpuDataFormat mapping: vector<uint8_t> → UINT8 vector<uint16_t> → UINT16 vector<uint32_t> → UINT32 vector<float> → FLOAT32 vector<double> → FLOAT32 (narrowed, warned) vector<complex<float>> → VEC2_F32 (identical layout to glm::vec2) vector<glm::vec2> → VEC2_F32 vector<glm::vec3> → VEC4_F32 (W=0 promotion, warned) vector<glm::vec4> → VEC4_F32 vector<complex<double>> → std::nullopt (logged error) vector<glm::mat4> → std::nullopt (logged error)

Definition at line 69 of file TextureAccess.cpp.

{
    return std::visit([](const auto& vec) -> std::optional<TextureAccess> {
        using T = typename std::decay_t<decltype(vec)>::value_type;
 
        if (vec.empty()) {
            MF_WARN(Journal::Component::Kakshya, Journal::Context::Runtime,
                "as_texture_access: empty variant");
            return std::nullopt;
        }
 
        // ---- rejected types ------------------------------------------------
 
        if constexpr (std::is_same_v<T, std::complex<double>>) {
            MF_ERROR(Journal::Component::Kakshya, Journal::Context::Runtime,
                "as_texture_access: complex<double> (RG64F) is not a sampled "
                "image format in Vulkan. Use complex<float> for RG32F.");
            return std::nullopt;
        }
 
        if constexpr (std::is_same_v<T, glm::mat4>) {
            MF_ERROR(Journal::Component::Kakshya, Journal::Context::Runtime,
                "as_texture_access: mat4 layout is ambiguous for texel upload. "
                "Unpack each column to a vec4 and use vector<glm::vec4>.");
            return std::nullopt;
        }
 
        // ---- zero-copy direct mappings ------------------------------------
 
        if constexpr (std::is_same_v<T, uint8_t>) {
            return TextureAccess {
                .data_ptr = vec.data(),
                .byte_count = vec.size() * sizeof(T),
                .format = GpuDataFormat::UINT8
            };
        }
 
        if constexpr (std::is_same_v<T, uint16_t>) {
            return TextureAccess {
                .data_ptr = vec.data(),
                .byte_count = vec.size() * sizeof(T),
                .format = GpuDataFormat::UINT16
            };
        }
 
        if constexpr (std::is_same_v<T, uint32_t>) {
            return TextureAccess {
                .data_ptr = vec.data(),
                .byte_count = vec.size() * sizeof(T),
                .format = GpuDataFormat::UINT32
            };
        }
 
        if constexpr (std::is_same_v<T, float>) {
            return TextureAccess {
                .data_ptr = vec.data(),
                .byte_count = vec.size() * sizeof(T),
                .format = GpuDataFormat::FLOAT32
            };
        }
 
        if constexpr (std::is_same_v<T, glm::vec2>
            || std::is_same_v<T, std::complex<float>>) {
            return TextureAccess {
                .data_ptr = vec.data(),
                .byte_count = vec.size() * sizeof(T),
                .format = GpuDataFormat::VEC2_F32
            };
        }
 
        if constexpr (std::is_same_v<T, glm::vec4>) {
            return TextureAccess {
                .data_ptr = vec.data(),
                .byte_count = vec.size() * sizeof(T),
                .format = GpuDataFormat::VEC4_F32
            };
        }
 
        // ---- narrowing: double → float -------------------------------------
 
        if constexpr (std::is_same_v<T, double>) {
            MF_WARN(Journal::Component::Kakshya, Journal::Context::Runtime,
                "as_texture_access: double narrowed to float for texel upload. "
                "Precision beyond float range is lost.");
            TextureAccess acc;
            acc.format = GpuDataFormat::FLOAT32;
            acc.conversion_buffer.resize(vec.size() * sizeof(float));
            auto* dst = reinterpret_cast<float*>(acc.conversion_buffer.data());
            for (size_t i = 0; i < vec.size(); ++i) {
                dst[i] = static_cast<float>(vec[i]);
            }
            acc.data_ptr = acc.conversion_buffer.data();
            acc.byte_count = acc.conversion_buffer.size();
            return acc;
        }
 
        // ---- promotion: vec3 → vec4 (W = 0) --------------------------------
 
        if constexpr (std::is_same_v<T, glm::vec3>) {
            MF_WARN(Journal::Component::Kakshya, Journal::Context::Runtime,
                "as_texture_access: vec3 promoted to vec4 (W=0). "
                "RGB32F is not a universally-supported sampled image format in Vulkan.");
            TextureAccess acc;
            acc.format = GpuDataFormat::VEC4_F32;
            acc.conversion_buffer.resize(vec.size() * sizeof(glm::vec4));
            auto* dst = reinterpret_cast<glm::vec4*>(acc.conversion_buffer.data());
            for (size_t i = 0; i < vec.size(); ++i) {
                dst[i] = glm::vec4(vec[i], 0.0F);
            }
            acc.data_ptr = acc.conversion_buffer.data();
            acc.byte_count = acc.conversion_buffer.size();
            return acc;
        }
 
        // ---- unreachable for current DataVariant definition ----------------
        MF_ERROR(Journal::Component::Kakshya, Journal::Context::Runtime,
            "as_texture_access: unhandled variant type {}",
            typeid(T).name());
        return std::nullopt;
    },
        variant);
}

References MayaFlux::Kakshya::TextureAccess::byte_count, MayaFlux::Kakshya::TextureAccess::conversion_buffer, MayaFlux::Kakshya::TextureAccess::data_ptr, FLOAT32, MayaFlux::Kakshya::TextureAccess::format, MayaFlux::Journal::Kakshya, MF_ERROR, MF_WARN, MayaFlux::Journal::Runtime, UINT16, UINT32, UINT8, VEC2_F32, and VEC4_F32.

Referenced by MayaFlux::Portal::Graphics::TextureLoom::create_2d(), and MayaFlux::Buffers::TextureProcessor::update_pixels_if_dirty().

Here is the caller graph for this function: