source: trunk/nv/interface/mesh.hh @ 111

// Copyright (C) 2012-2013 ChaosForge / Kornel Kisielewicz
// http://chaosforge.org/
//
// This file is part of NV Libraries.
// For conditions of distribution and use, see copyright notice in nv.hh

/**
 * @file mesh.hh
 * @author Kornel Kisielewicz
 * @brief mesh
 */

#ifndef NV_MESH_HH
#define NV_MESH_HH

#include <nv/common.hh>
#include <nv/string.hh>
#include <nv/types.hh>
#include <nv/interface/context.hh>
#include <unordered_map>
#include <vector>

namespace nv
{
        class vertex_attribute_base
        {
        public:
                vertex_attribute_base( const string& name, datatype attrtype ) 
                        : m_name( name ), m_type( attrtype ) {}
                const string& get_name() const { return m_name; }
                datatype get_type() const { return m_type; }
                virtual datatype get_base_type() const = 0;
                virtual size_t get_components() const = 0;
                virtual size_t get_count() const = 0;
                virtual size_t get_size() const = 0;
                virtual void* get_data() const = 0;
                virtual ~vertex_attribute_base() {};
        private:
                string m_name;
                datatype  m_type;
        };

        template< typename T >
        class vertex_attribute : public vertex_attribute_base
        {
        public:
                typedef T value_type;
                typedef typename datatype_traits<T>::base_type base_type;
                typedef std::vector<T> list;

                vertex_attribute( const string& name ) : vertex_attribute_base( name, type_to_enum<T>::type ) {}
                const list& get() const { return m_list; }
                list& get() { return m_list; }
                virtual datatype get_base_type() const { return type_to_enum<base_type>::type; };
                virtual size_t get_components() const { return datatype_traits<T>::size; };
                virtual size_t get_count() const { return m_list.size(); }
                virtual size_t get_size() const { return m_list.size() * sizeof(T); }
                virtual void* get_data() const { return (void*)m_list.data(); }
        private:
                list m_list;
        };


        class mesh
        {
        public:
                typedef std::unordered_map< std::string, vertex_attribute_base* > map;

                mesh( primitive p = TRIANGLES, culling::order_type c = culling::CCW ) 
                        : m_map(), m_indices(), m_primitive( p ), m_order( c ) {}
                template <typename T>
                vertex_attribute<T>* add_attribute( const string& attr ) 
                { 
                        vertex_attribute<T>* result = new vertex_attribute<T>( attr ); 
                        m_map[ attr ] = result;
                        return result;
                }
                template <typename T>
                vertex_attribute<T>* add_indices() 
                { 
                        if ( m_indices ) delete m_indices; // error?
                        m_indices = new vertex_attribute<T>(""); 
                        return m_indices;
                }

                vertex_attribute_base* get_attribute( const string& attr )
                {
                        map::iterator i = m_map.find( attr );
                        return i != m_map.end() ? i->second : nullptr;
                }

                template <typename T>
                vertex_attribute<T>* get_attribute( const string& attr )
                {
                        map::iterator i = m_map.find( attr );
                        if ( i != m_map.end() && i->second->get_type() != type_to_enum<T>() ) 
                        {
                                return ((vertex_attribute<T>*)(i->second));
                        }
                        return nullptr;
                }

                const vertex_attribute_base* get_indices() const { return m_indices; }
                vertex_attribute_base* get_indices() { return m_indices; }

                template <typename T>
                vertex_attribute<T>* get_indices() 
                {
                        return m_indices->get_type() == type_to_enum<T>() ? ((vertex_attribute<T>*)(m_indices)) : nullptr; 
                }

                const map& get_attributes() const { return m_map; }
                primitive get_primitive() const { return m_primitive; }
                bool has_indices() const { return m_indices != nullptr; }

                ~mesh() 
                {
                        delete m_indices;
                        for ( auto& v : m_map )
                        {
                                delete v.second;
                        }
                }
        private:
                map                    m_map;
                vertex_attribute_base* m_indices;
                primitive              m_primitive;
                culling::order_type    m_order;

        };

}


#endif // NV_MESH_HH