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)
        {}
 
        MemCore::RefPtr<IndexBufferObject> sort(const DepthToIndexMap&points) override
        {
                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                 offset, npoints,
                                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();
 
        bool draw() override;
};
 
typedef ElementRenderer PartialElementRenderer;
 
} // namespace GL
 
#endif // __PartialElementRenderer_HPP