PartialElementRenderer.hpp

#ifndef __PartialElementRenderer_HPP
#define __PartialElementRenderer_HPP

#include <GLvish/VBO.hpp>
#include <GLvish/IndexBuffer.hpp>
#include <GLvish/VGLRenderContext.hpp>
#include <field/FragmentSelector.hpp>

#include "fishGLDllApi.h"

namespace GL
{

typedef Fiber::index_t index_t;
typedef std::multimap<double, index_t> DepthToIndexMap;

using Wizt::IndexBuffer;
using Wizt::IndexBufferObject;

template <class Type>
MemCore::RefPtr<IndexBuffer<Type> > SortElements(const std::vector<Type>&UnsortedElements,
                                                 const DepthToIndexMap&points)
{
using std::vector; 

std::vector<Type> SortedElements( UnsortedElements.size() );
typename std::vector<Type>::iterator SortedElementsIterator = SortedElements.begin();

        for(DepthToIndexMap::const_iterator it = points.begin(); 
            it != points.end(); it++)
        {
        index_t sorted_idx = it->second;
                *SortedElementsIterator = UnsortedElements[ sorted_idx ]; 
                 SortedElementsIterator++;
        }
#ifdef  VERBOSE 
        puts("indices copied, creating index buffer");fflush(stdout);
#endif
        return newIndexBuffer(SortedElements);
}

struct  fishGL_API ElementSorter : MemCore::ReferenceBase<ElementSorter>
{
        ElementSorter()
        : MemCore::ReferenceBase<ElementSorter>(this)
        {} 

        ~ElementSorter(); 

static  MemCore::RefPtr<IndexBufferObject> sortPoints(const DepthToIndexMap&points);
        virtual MemCore::RefPtr<IndexBufferObject> sort(const DepthToIndexMap&points);
};

template <class Type>
struct  fishGL_API TypedElementSorter : ElementSorter
{
        MemCore::RefPtr<Fiber::CreativeArrayBase> BaryCenters; 
        typedef Fiber::MemArray<1, Type>           CellArray_t; 

        TypedElementSorter(const MemCore::RefPtr<Fiber::CreativeArrayBase>&BC)
        : BaryCenters(BC)
        {}

        override MemCore::RefPtr<IndexBufferObject> sort(const DepthToIndexMap&points)
        {
                assert( BaryCenters ); 
        MemCore::RefPtr<CellArray_t> Cells = BaryCenters->create(); 
                assert( Cells ); 

        MemCore::RefPtr<MemCore::TypedChunk<Type> > C = Cells->getStorage(); 
                assert( C );

        MemCore::RefPtr<IndexBuffer<Type> > 
                IB = SortElements(C->get_vector(), points); 

                return IB;
        }
};

struct  fishGL_API ElementRenderer : Wizt::VBO::Renderer
{
        typedef MemCore::RefPtr<Wizt::IndexBufferObject>        IBO_t;

        typedef Fiber::MemArray<3, IBO_t> ViewBufferArray_t; 

        MemCore::RefPtr<ViewBufferArray_t> SortedIndices;

        IBO_t                   CurrentIBO; 

        MemCore::RefPtr<ElementSorter>  MyElementSorter;

        GLenum                  draw_mode;
        GLsizei                 count; 

        IBO_t   sortByDepth(Wizt::VRenderContext&Context,
                            const MemCore::RefPtr<Fiber::CreativeArrayBase>&VertexCoordinates,
                            unsigned Discretization = 2);

        ElementRenderer(const MemCore::RefPtr<Fiber::MemBase>&FieldCoordinates,
                        const MemCore::RefPtr<Fiber::FragmentSelector>&FS); 

        ~ElementRenderer();

        override bool draw();
};

typedef ElementRenderer PartialElementRenderer;

} // namespace GL

#endif // __PartialElementRenderer_HPP