FieldBuffer.hpp

#ifndef __FieldBuffer_HPP
#define __FieldBuffer_HPP

#include <field/Field.hpp>
#include <GLvish/ArrayTypes.hpp>
#include <plankton/VActionNotifier.hpp>
#include "fishGLDllApi.h"

namespace GL
{
        using namespace Wizt;

template <class ArrayType>
bool LoadArray(ArrayType&What, const MemCore::RefPtr<Fiber::MemBase>&SRC,
               BufferArray::usage usage_hint = BufferArray::STATIC_DRAW)
{
typedef typename ArrayType::value_type  value_type;

Fiber::TypedIterator<value_type> TI = SRC;
        if (!TI)
                return false;

Fiber::CreativeIterator<value_type> it = *TI; 

        return What.load(it.ptr(), it.count()*sizeof(value_type), it.count(), usage_hint ); 
}

template <class ArrayType>
struct  FieldBuffer
{
        typedef typename ArrayType::value_type  value_type;
        typedef typename ArrayType::Base_t      Base_t;

static  MemCore::RefPtr<Base_t> create(const MemCore::RefPtr<Fiber::MemBase>&MB, bool ForceMemCreation, 
                                       const Fiber::MemBase::Creator_t&theCreator, BufferArray::usage usage_hint = BufferArray::STATIC_DRAW)
        {
        using namespace MemCore;
        using namespace Fiber;

                if (!MB)
                        throw BufferArray::Error("GL::FieldBuffer::create() No array data given", typeid(ArrayType), typeid(value_type) ); 
//                      return MemCore::NullPtr();

        MemCore::RefPtr<TypedArray<value_type> > TA = MB;
                if (!TA)
                        throw BufferArray::Error("Unexpected array data given", typeid(value_type), MB->getType() );
//                      return MemCore::NullPtr();

        CreativeIterator<value_type>*TI = TA->creativeIterator();
                if (!TI)
                {
                        //printf("FieldBuffer(): Could not create CreativeIterator\n"); 
                        //TA.speak("FieldBuffer failure");
                        if (ForceMemCreation)
                        {
                                TA = MB->makeMemArray(theCreator);
                                if (!TA)
                                {
                                        printf("FieldBuffer(): Could not create memory implementaion of procedural data!\n"); 
                                        return MemCore::NullPtr();
                                }
                                TI = TA->creativeIterator();
                                if (!TI)
                                {
                                        printf("FieldBuffer(): Ouch, memory copy does not have a CreativeIterator - internal bug?\n"); 
                                        return MemCore::NullPtr();
                                }
                        }
                        else
                        {
                                printf("FieldBuffer(): Could not create CreativeIterator\n"); 
                                VActionNotifier::Warning("FieldBuffer(): Could not create CreativeIterator\n"); 
                                return MemCore::NullPtr();
                        }

                        //printf("FieldBuffer():    all is right now due to in-memory creation\n"); 
                }

        MemCore::RefPtr<ArrayType> B = new ArrayType();
                if (!B->load(TI->ptr(), TI->count()*sizeof(value_type), TI->count(), usage_hint ) )
                {
                        throw BufferArray::Error("Cannot load array data", typeid(value_type), MB->getType() ); 
                }
                return B;
        }

template <class ArrayConstructorParam>
static  MemCore::RefPtr<Base_t> createParam(const ArrayConstructorParam&AParam, const MemCore::RefPtr<Fiber::MemBase>&MB, 
                                            bool ForceMemCreation,  const Fiber::MemBase::Creator_t&theCreator,
                                            BufferArray::usage usage_hint = BufferArray::STATIC_DRAW)
        {
        using namespace MemCore;
        using namespace Fiber;

                if (!MB)
                        throw BufferArray::Error("GL::FieldBuffer::create(param): No array data given", typeid(ArrayType), typeid(value_type) ); 
//                      return MemCore::NullPtr();

        MemCore::RefPtr<TypedArray<value_type> > TA = MB;
                if (!TA)
                        throw BufferArray::Error("Unexpected array data given", typeid(value_type), MB->getType() ); 
//                      return MemCore::NullPtr();

        CreativeIterator<value_type>*TI = TA->creativeIterator();
                if (!TI)
                {
                        printf("FieldBuffer(): Could not create CreativeIterator\n"); 
                        if (ForceMemCreation)
                        {
                                TA = MB->makeMemArray( theCreator );
                                if (!TA)
                                {
                                        printf("FieldBuffer(): Could not create memory implementation of procedural data!\n"); 
                                        return MemCore::NullPtr();
                                }
                                TI = TA->creativeIterator(); 
                                if (!TI)
                                {
                                        printf("FieldBuffer(): Ouch, memory copy does not have a CreativeIterator - internal bug?\n"); 
                                        return MemCore::NullPtr();
                                }
                        }
                        else
                                return MemCore::NullPtr();
                } 
        MemCore::RefPtr<ArrayType> B = new ArrayType(AParam); 
                if (!B->load(TI->ptr(), TI->count()*sizeof(value_type), TI->count(), usage_hint ) )
                {
                        throw BufferArray::Error("Cannot load array data", typeid(value_type), MB->getType() );
                        return NullPtr();
                } 
                return B;
        }

};

template <>
struct fishGL_API FieldBuffer<VertexArray>
{
static  MemCore::RefPtr<VertexArray> create(const MemCore::RefPtr<Fiber::MemBase>&MB, bool ForceMemCreation,
                                            const Fiber::MemBase::Creator_t&theCreator = NullPtr() );
};

template <>
struct fishGL_API FieldBuffer<TexCoordArray>
{
static  MemCore::RefPtr<TexCoordArray> create(const MemCore::RefPtr<Fiber::MemBase>&MB, bool ForceMemCreation,
                                              const Fiber::MemBase::Creator_t&theCreator = NullPtr() );
};

template <>
struct fishGL_API FieldBuffer<NormalArray>
{
static  MemCore::RefPtr<NormalArray> create(const MemCore::RefPtr<Fiber::MemBase>&MB, bool ForceMemCreation,
                                            const Fiber::MemBase::Creator_t&theCreator = NullPtr() );
};


} // namespace

#endif // __FieldBuffer_HPP