source: trunk/nv/interface/data_channel.hh @ 421

// Copyright (C) 2012-2015 ChaosForge Ltd
// http://chaosforge.org/
//
// This file is part of Nova libraries. 
// For conditions of distribution and use, see copying.txt file in root folder.

#ifndef NV_INTERFACE_DATA_CHANNEL_HH
#define NV_INTERFACE_DATA_CHANNEL_HH

#include <nv/common.hh>
#include <nv/stl/vector.hh>
#include <nv/interface/data_descriptor.hh>

namespace nv
{

        struct raw_data_channel
        {
                raw_data_channel( raw_data_channel&& other )
                {
                        m_data = other.m_data;
                        m_size = other.m_size;
                        m_desc = other.m_desc;
                        other.m_data = nullptr;
                        other.m_size = 0;
                }

                raw_data_channel& operator=( raw_data_channel&& other )
                {
                        if ( this != &other )
                        {
                                if ( m_data != nullptr ) delete[] m_data;
                                m_data = other.m_data;
                                m_size = other.m_size;
                                m_desc = other.m_desc;
                                other.m_data = nullptr;
                                other.m_size = 0;
                        }
                        return *this;
                }


                const data_descriptor& descriptor() const { return m_desc; }
                uint32 element_size() const { return m_desc.element_size(); }
                uint32 size() const { return m_size; }
                uint32 raw_size() const { return m_size * m_desc.element_size(); }
                const uint8* raw_data() const { return m_data; }

                // TODO: constexpr compile-time cast check?
                template < typename Struct >
                const Struct* data_cast() const
                {
                        return reinterpret_cast<const Struct*>( m_data );
                }

                bool has_slot( slot vslot ) const { return m_desc.has_slot( vslot ); }

                ~raw_data_channel()
                {
                        if ( m_data != nullptr ) delete[] m_data;
                }

        protected:

                template < typename Struct >
                friend class data_channel_access;
                friend class raw_data_channel_access;
                friend class data_channel_creator;
                friend class data_channel_set;

                raw_data_channel() : m_data( nullptr ), m_size( 0 ) {}
                raw_data_channel( const raw_data_channel& ) = delete;
                raw_data_channel& operator=( const raw_data_channel& ) = delete;

                uint8*          m_data;
                uint32          m_size;
                data_descriptor m_desc;
        };

        class data_channel_set
        {
        public:
                friend class data_channel_set_creator;
                friend class raw_data_channel_access;

                typedef const raw_data_channel* const_iterator;

                data_channel_set( data_channel_set&& other )
                {
                        for ( uint32 c = 0; c < other.m_size; ++c )
                                m_channels[c] = move( other.m_channels[c] );
                        m_size = other.m_size;
                        other.m_size = 0;
                }

                data_channel_set& operator=( data_channel_set&& other )
                {
                        if ( this != &other )
                        {
                                for ( uint32 c = 0; c < other.m_size; ++c )
                                        m_channels[c] = move( other.m_channels[c] );
                                m_size = other.m_size;
                                other.m_size = 0;
                        }
                        return *this;
                }

                size_t size() const { return m_size; }

                const raw_data_channel* get_channel( size_t index ) const
                {
                        if ( m_size > index ) return &m_channels[index];
                        return nullptr;
                }

                const raw_data_channel* get_channel( slot s ) const
                {
                        for ( uint32 c = 0; c < m_size; ++c )
                                if ( m_channels[c].has_slot( s ) )
                                return &m_channels[c];
                        return nullptr;
                }

                template < typename Struct >
                const raw_data_channel* get_channel() const
                {
                        data_descriptor compare;
                        compare.initialize<Struct>();
                        for ( uint32 c = 0; c < m_size; ++c )
                        {
                                if ( m_channels[c].descriptor() == compare )
                                {
                                        return &m_channels[c];
                                }
                        }
                        return nullptr;
                }

                size_t get_channel_size( slot s ) const
                {
                        const raw_data_channel* channel = get_channel( s );
                        return channel ? channel->size() : 0;
                }

                size_t get_channel_size( size_t channel ) const
                {
                        if ( m_size > channel ) return m_channels[channel].size();
                        return 0;
                }

                template < typename Struct >
                size_t get_channel_size() const
                {
                        data_descriptor compare;
                        compare.initialize<Struct>();
                        for ( uint32 c = 0; c < m_size; ++c )
                        {
                                if ( m_channels[c].descriptor() == compare )
                                {
                                        return m_channels[c].size();
                                }
                        }
                        return 0;
                }

                template < typename VTX >
                const VTX* get_channel_data() const
                {
                        data_descriptor compare;
                        compare.initialize<VTX>();
                        for ( uint32 c = 0; c < m_size; ++c )
                        {
                                if ( m_channels[c].descriptor() == compare )
                                {
                                        return m_channels[c].data_cast<VTX>( );
                                }
                        }
                        return nullptr;
                }

                int get_channel_index( slot s ) const
                {
                        for ( uint32 c = 0; c < m_size; ++c )
                                if ( m_channels[c].has_slot( s ) )
                                return int( c );
                        return -1;
                }

                data_descriptor get_interpolation_key() const
                {
                        data_descriptor result;
                        for ( uint32 c = 0; c < m_size; ++c )
                        {
                                for ( const auto& cslot : m_channels[c].descriptor() )
                                        if ( cslot.vslot != slot::TIME )
                                        result.push_slot( cslot.etype, cslot.vslot );
                        }
                        return result;
                }

                const_iterator begin() const { return &m_channels[0]; }
                const_iterator end()   const { return &m_channels[ m_size ]; }
        protected:

                data_channel_set()
                {
                        m_size = 0;
                }
                raw_data_channel m_channels[4];
                uint32 m_size;
        };

}

#endif // NV_INTERFACE_DATA_CHANNEL_HH