component_format.h

#pragma once
 
#include <cgv/type/info/type_id.h>
#include <cgv/type/info/type_access.h>
#include "packing_info.h"
#include <string>
#include <vector>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace data {
 
enum ComponentFormat {
    CF_UNDEF, 
    CF_R,        
    CF_G,        
    CF_B,        
    CF_A,        
    CF_L,     
    CF_I,     
    CF_LA,    
    CF_IA,    
    CF_RG,    
    CF_RGB,   
    CF_RGBA,  
    CF_BGR,   
    CF_BGRA,  
    CF_D,     
    CF_S,     
    CF_P2D,   
    CF_P3D,   
    CF_P4D,   
    CF_N2D,   
    CF_N3D,   
    CF_T2D,   
    CF_T3D,   
    CF_T4D,   
    CF_LAST   
};
 
enum ComponentIntegerInterpretation
{
    CII_DEFAULT, // default of used api such as opengl
    CII_SNORM,   // map signed integers to [-1,1]
    CII_INTEGER  // keep integer values even if api would map them to [0,1]
};
 
class CGV_API component_format : public packing_info
{ 
protected:
    cgv::type::info::TypeId component_type;
    ComponentIntegerInterpretation component_interpretation;
    std::string component_string;
    std::vector<unsigned short> component_positions;
    void extract_components();
    static std::string last_error;
public:
    explicit component_format(const std::string& description);
    bool set_component_format(const std::string& description);
    void set_components(const std::string& _components);
    static const std::string& get_last_error();
    component_format(cgv::type::info::TypeId _component_type = cgv::type::info::TypeId::TI_UNDEF, const std::string& _component_name_list = "",
        unsigned align = 1, unsigned d0 = 0, unsigned d1 = 0, unsigned d2 = 0, unsigned d3 = 0);
    component_format(cgv::type::info::TypeId _component_type, ComponentFormat cf,
        unsigned align = 1, unsigned d0 = 0, unsigned d1 = 0, unsigned d2 = 0, unsigned d3 = 0);
    void set_integer_interpretation(ComponentIntegerInterpretation cii);
    ComponentIntegerInterpretation get_integer_interpretation() const;
    friend FRIEND_MEMBER_API std::ostream& operator << (std::ostream& os, const component_format& cf);
    template <typename T>
    T get(int ci, const void* ptr) const {
        if (is_packing()) {
            if (get_component_type() <= cgv::type::info::TI_INT64) {
                int i = packing_info::get_signed(ci, ptr);
                return cgv::type::info::type_access<T>::get(&i, get_component_type());
            }
            else {
                unsigned int i = packing_info::get_unsigned(ci, ptr);
                return cgv::type::info::type_access<T>::get(&i, get_component_type());
            }
        }
        else
            return cgv::type::info::type_access<T>::get(static_cast<const unsigned char*>(ptr)+ci*align(get_type_size(get_component_type()),get_component_alignment()), get_component_type());
    }
    template <typename T>
    bool set(int ci, void* ptr, const T& v) const { 
        if (is_packing()) {
            if (get_component_type() <= cgv::type::info::TI_INT64) {
                int i = 0;
                return cgv::type::info::type_access<T>::set(&i, get_component_type(), v) && packing_info::set_signed(ci, ptr, i);
            }
            else {
                unsigned int i = 0;
                return cgv::type::info::type_access<T>::set(&i, get_component_type(), v) && packing_info::set_unsigned(ci, ptr, i);
            }
        }
        else
            return cgv::type::info::type_access<T>::set(static_cast<unsigned char*>(ptr)+ci*align(get_type_size(get_component_type()),get_component_alignment()), get_component_type(), v);
    }
    bool empty() const;
    void clear();
    const packing_info& get_packing_info() const;
    void set_packing_info(const packing_info& pi);
    unsigned int get_nr_components() const;
    unsigned int get_component_index(const std::string& name) const;
    std::string get_component_name(unsigned int i) const;
    ComponentFormat get_standard_component_format() const;
    void set_component_names(const std::string& _component_name_list);
    void set_component_format(ComponentFormat _cf);
    cgv::type::info::TypeId get_component_type() const;
    void set_component_type(cgv::type::info::TypeId _type_id);
    unsigned int get_entry_size() const;
    bool operator == (const component_format& cf) const;
    bool operator != (const component_format& cf) const;
};
 
extern CGV_API std::ostream& operator << (std::ostream& os, const component_format& cf);
 
extern CGV_API bool fmt1_compares_better(const component_format& fmt,
                                              const component_format& fmt1,
                                              const component_format& fmt2);
 
extern CGV_API unsigned int find_best_match(
                const component_format& fmt,
                const char** format_descriptions,
                const component_format* fmt0 = 0,
                bool (*fmt1_better_match)(
                   const component_format& fmt,
                    const component_format& fmt1,
                    const component_format& fmt2) = fmt1_compares_better);
 
    }
}
 
#include <cgv/config/lib_end.h>