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"
 
using namespace cgv::type::info;
 
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:
        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(TypeId _component_type = TI_UNDEF, 
                const std::string& _component_name_list = "", 
                unsigned int align = 1, 
                unsigned int d0 = 0, unsigned int d1 = 0, 
                unsigned int d2 = 0, unsigned int d3 = 0);
        component_format(TypeId _component_type, 
                ComponentFormat cf, 
                unsigned int align = 1, 
                unsigned int d0 = 0, unsigned int d1 = 0, 
                unsigned int d2 = 0, unsigned int 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() <= TI_INT64) {
                                int i = packing_info::get_signed(ci, ptr);
                                return type_access<T>::get(&i, get_component_type());
                        }
                        else {
                                unsigned int i = packing_info::get_unsigned(ci, ptr);
                                return type_access<T>::get(&i, get_component_type());
                        }
                }
                else
                        return 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() <= TI_INT64) {
                                int i = 0;
                                return type_access<T>::set(&i, get_component_type(), v) && packing_info::set_signed(ci, ptr, i);
                        }
                        else {
                                unsigned int i = 0;
                                return type_access<T>::set(&i, get_component_type(), v) && packing_info::set_unsigned(ci, ptr, i);
                        }
                }
                else
                        return 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);
        TypeId get_component_type() const;
        void set_component_type(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>