streaming_mesh.h

#pragma once
 
#include <vector>
#include <deque>
#include <cgv/math/fvec.h>
 
namespace cgv {
        namespace media {
                namespace mesh {
 
struct streaming_mesh_callback_handler
{
        virtual void new_vertex(unsigned int vertex_index) = 0;
        virtual void new_polygon(const std::vector<unsigned int>& vertex_indices) = 0;
        virtual void before_drop_vertex(unsigned int vertex_index) = 0;
};
 
template <typename T>
class streaming_mesh
{
public:
        typedef cgv::math::fvec<T,3> pnt_type;
        typedef cgv::math::fvec<T,3> vec_type;
protected:
        int idx_off;
        unsigned int nr_faces;
        std::deque<pnt_type> pnts;
        std::deque<vec_type> nmls;
        streaming_mesh_callback_handler* smcbh;
public:
        streaming_mesh(streaming_mesh_callback_handler* _smcbh = 0) : smcbh(_smcbh), nr_faces(0), idx_off(0) {
        }
        void set_callback_handler(streaming_mesh_callback_handler* _smcbh) {
                smcbh = _smcbh;
        }
        unsigned int get_nr_dropped_vertices() const           { return idx_off; }
        unsigned int get_nr_vertices() const                   { return (unsigned int) pnts.size()+idx_off; }
        unsigned int get_nr_faces() const                      { return nr_faces; }
        void drop_vertex() {
                if (pnts.empty())
                        return;
                if (smcbh)
                        smcbh->before_drop_vertex(idx_off);
                pnts.pop_front();
                nmls.pop_front();
                ++idx_off;
        }
        void drop_vertices(unsigned int n) {
                for (unsigned int i=0; i<n; ++i)
                        drop_vertex();
        }
                   pnt_type& vertex_location(unsigned int vi)       { return pnts[vi-idx_off]; }
        const pnt_type& vertex_location(unsigned int vi) const { return pnts[vi-idx_off]; }
        const vec_type& vertex_normal(unsigned int vi) const   { return nmls[vi-idx_off]; }
         vec_type& vertex_normal(unsigned int vi)         { return nmls[vi-idx_off]; }
        unsigned int new_vertex(const pnt_type& p) {
                unsigned int vi = (int)pnts.size()+idx_off;
                pnts.push_back(p);
                nmls.push_back(vec_type(0,0,0));
                if (smcbh)
                        smcbh->new_vertex(vi);
                return vi;
        }
        void new_triangle(unsigned int vi, unsigned int vj, unsigned int vk) {
                static std::vector<unsigned int> vis(3);
                vis[0] = vi;
                vis[1] = vj;
                vis[2] = vk;
                ++nr_faces;
                if (smcbh)
                        smcbh->new_polygon(vis);
        }
        void new_quad(unsigned int vi, unsigned int vj, unsigned int vk, unsigned int vl) {
                static std::vector<unsigned int> vis(4);
                vis[0] = vi;
                vis[1] = vj;
                vis[2] = vk;
                vis[3] = vl;
                ++nr_faces;
                if (smcbh)
                        smcbh->new_polygon(vis);
        }
        void new_polygon(const std::vector<unsigned int>& vertex_indices) {
                ++nr_faces;
                if (smcbh)
                        smcbh->new_polygon(vertex_indices);
        }
};
 
                }
        }
}