VertexField.hpp

#ifndef __VERTEXFIELD_HPP
#define __VERTEXFIELD_HPP
 
 
#include <bone/BundleInput.hpp>
#include <bone/FishField.hpp>
#include <bone/FishSlice.hpp>
 
#include <ocean/GLvish/VGLRenderObject.hpp>
#include <ocean/GLvish/ArrayTypes.hpp>
#include <ocean/GLvish/Shader.hpp>
 
#include <eagle/PhysicalSpace.hpp>
 
#include <ocean/shrimp/VEnum.hpp>
 
#include <GL/fieldGL.hpp>
#include <GL/FieldBuffer.hpp>
 
#include "fisheyeDllApi.h"
 
namespace Wizt
{
 
class    fisheye_API  VertexField : public MemCore::ReferenceBase<VertexField>
{
public:
        TypedSlot<Fiber::Field>  MyField;
 
        struct  Error : GLError
        {
                MemCore::simplestring   fieldname;
 
                Error(const char*what, const string&f, const char*srcfilename, unsigned lineNo)
                : GLError(0, what, srcfilename, lineNo)
                , fieldname(f)
                {
                }
        };
 
        const bool ConvertToElements = false;
 
        VertexField(VObject*what,
                    const string&fieldname, bool ConvertToElements=true,
                    int expertLevel=0);
 
        ~VertexField();
 
        virtual RefPtr<BufferArray> createVBOArray(const RefPtr<Fiber::MemBase>&MB,
                                                   const string&arrayname,
                                                   const RefPtr<GLProgram>&Shader,
                                                   const Fiber::MemBase::Creator_t&theCreator) const = 0;
 
        bool    append(VBO&myVBO, const RefPtr<Fiber::CreativeArrayBase>&CAb,
                       const string&arrayname, const RefPtr<GLProgram>&Shader
                       ) const;
 
        virtual bool isOlderThan(const Ageable&A, const RefPtr<ValuePool>&Context) const;
 
        virtual void updateAge(Ageable&A, const RefPtr<ValuePool>&Context) const;
};
 
template <class VBOArrayType>
class   VBOField : public VertexField
{
public:
        typedef typename VBOArrayType::value_type value_type;
 
        VBOField(VObject*that, const string&fieldname, int expertLevel=0)
        : VertexField(that, fieldname, true, expertLevel)
        {
        TypedSlot<Fiber::Field>&myField = this->MyField;
                myField.acceptType<value_type>();
        }
 
        RefPtr<BufferArray> createVBOArray(const RefPtr<Fiber::MemBase>&MB,
                                                    const string&arrayname,
                                                    const RefPtr<GLProgram>&Shader,
                                                    const Fiber::MemBase::Creator_t&theCreator
                                                    ) const override
        {
//              return GL::FieldBuffer<VBOArrayType>::create( MB, ConvertToElements );
                return GL::FieldBuffer<VBOArrayType>::create( MB, true, theCreator );
        }
};
 
 
template <class Type>
class   VBOField<TypedTexCoordArray<Type> > : public VertexField
{
public:
        typedef TypedTexCoordArray<Type> VBOArrayType;
        typedef typename VBOArrayType::value_type value_type;
 
        int     TU;
 
        VBOField(VObject*that, const string&fieldname, int TextureUnit, int expertLevel = 0)
        : VertexField(that, fieldname, true, expertLevel)
        , TU(TextureUnit)
        {
        TypedSlot<Fiber::Field>&myField = this->MyField;
                myField.acceptType<value_type>();
        }
 
        RefPtr<BufferArray> createVBOArray(const RefPtr<Fiber::MemBase>&MB,
                                           const string&arrayname,
                                           const RefPtr<GLProgram>&Shader,
                                           const Fiber::MemBase::Creator_t&theCreator) const override
        {
        int     Id = TU;
#if 0
                if (Shader)
                {
                        if (!Shader->getUniformValuei( arrayname.c_str(), Id ) )
                        {
                                throw BufferArray::Error("No texture ID defined in associated shader", typeid(Type), MB->getType() );
                        }
                }
#endif
//              return GL::FieldBuffer<VBOArrayType>::create( MB, ConvertToElements );
                return GL::FieldBuffer<VBOArrayType>::createParam(Id, MB, true, theCreator );
        }
};
 
template <class Type>
class   VBOField<TypedVertexAttribArray<Type> > : public VertexField
{
public:
        typedef TypedVertexAttribArray<Type> VBOArrayType;
        typedef typename VBOArrayType::value_type value_type;
 
        VBOField(VObject*that, const string&fieldname, int EL=0)
        : VertexField(that, fieldname, true, EL)
        {
        TypedSlot<Fiber::Field>&myField = this->MyField;
                myField.acceptType<value_type>();
        }
 
        RefPtr<BufferArray> createVBOArray(const RefPtr<Fiber::MemBase>&MB,
                                           const string&arrayname,
                                           const RefPtr<GLProgram>&Shader,
                                           const Fiber::MemBase::Creator_t&theCreator) const override
        {
                if (!Shader)
                        return NullPtr();
 
        int     Id = Shader->getAttribID( arrayname.c_str() );
                if (Id<0)
                        throw BufferArray::Error("Vertex Attribute '" + arrayname + "' was not found in vertex shader.",
                                                 typeid(Type), MB->getType(), __FILE__, __LINE__ );
 
//                      throw BufferArray::Error("Invalid attribute ID used in associated shader", typeid(Type), MB->getType() );
 
                return GL::FieldBuffer<VBOArrayType>::createParam(Id, MB, true, theCreator );
        }
};
 
template <class VBOArrayType>
class   VBOField<LIST<VBOArrayType, NIL> > : public VBOField<VBOArrayType>
{
public:
//      typedef typename VBOArrayType::value_type value_type;
 
        VBOField(VObject*that, const string&fieldname, int EL=0)
        : VBOField<VBOArrayType>(that, fieldname, EL)
        {
//      TypedSlot<Fiber::Field>&myField = this->MyField;
//              myField.acceptType<value_type>();
        }
 
/* taken from base class
        RefPtr<BufferArray> createVBOArray(const RefPtr<Fiber::MemBase>&MB,
                                                    const string&arrayname,
                                                    const RefPtr<GLProgram>&Shader,
                                                    const Fiber::MemBase::Creator_t&theCreator
                                                    ) const override
        {
//              return GL::FieldBuffer<VBOArrayType>::create( MB, ConvertToElements );
                return GL::FieldBuffer<VBOArrayType>::create( MB, true, theCreator );
        }
*/
};
 
 
template <class VBOArrayType, class NextType>
class   VBOField<LIST<VBOArrayType, NextType> > : public VBOField<NextType>
{
public:
        typedef typename VBOArrayType::value_type value_type;
 
        VBOField(VObject*that, const string&fieldname, int EL=0)
        : VBOField<NextType>(that, fieldname, EL)
        {
        TypedSlot<Fiber::Field>&myField = this->MyField;
                myField.acceptType<value_type>();
        }
 
        RefPtr<BufferArray> createVBOArray(const RefPtr<Fiber::MemBase>&MB,
                                                    const string&arrayname,
                                                    const RefPtr<GLProgram>&Shader,
                                                    const Fiber::MemBase::Creator_t&theCreator
                                                    ) const override
        {
                if (RefPtr<BufferArray> BufferArrayForThisType =
                    GL::FieldBuffer<VBOArrayType, false>::create( MB, true, theCreator ) )
                {
                        return BufferArrayForThisType;
                }
#ifdef  VERBOSE
                printf("VBO: Could not load data as %s, trying to load as %s next.\n",
                       Typename(typeid(VBOArrayType)).c_str(), Typename(typeid(NextType)).c_str() );
                fflush(stdout);
#endif
                return VBOField<NextType>::createVBOArray(MB, arrayname, Shader, theCreator);
        }
};
 
 
template <class Type>
class   VBOField<LIST<TypedVertexAttribArray<Type>, NIL> > : public VBOField<TypedVertexAttribArray<Type> >
{
public:
        VBOField(VObject*that, const string&fieldname, int EL=0)
        : VBOField<TypedVertexAttribArray<Type> >(that, fieldname, EL)
        {}
};
 
 
template <class Type, class NextType>
class   VBOField<LIST<TypedVertexAttribArray<Type>, NextType> > : public VBOField<NextType>
{
public:
        typedef TypedVertexAttribArray<Type> VBOArrayType;
        typedef typename VBOArrayType::value_type value_type;
 
        VBOField(VObject*that, const string&fieldname, int EL=0)
        : VBOField<NextType>(that, fieldname, EL)
        {
        TypedSlot<Fiber::Field>&myField = this->MyField;
                myField.acceptType<value_type>();
        }
 
        RefPtr<BufferArray> createVBOArray(const RefPtr<Fiber::MemBase>&MB,
                                                    const string&arrayname,
                                                    const RefPtr<GLProgram>&Shader,
                                                    const Fiber::MemBase::Creator_t&theCreator
                                                    ) const override
        {
                if (!Shader)
                        return NullPtr();
 
        int     Id = Shader->getAttribID( arrayname.c_str() );
                if (Id<0)
                        throw BufferArray::Error("Vertex Attribute '" + arrayname + "' was not found in vertex shader.",
                                                 typeid(Type), MB->getType(), __FILE__, __LINE__ );
 
                if (RefPtr<BufferArray> BufferArrayForThisType =
                    GL::FieldBuffer<VBOArrayType, false>::createParam(Id, MB, true, theCreator ) )
                {
                        return BufferArrayForThisType;
                }
 
#ifdef  VERBOSE
                printf("VBO: Could not load data as %s, trying to load as %s next.\n",
                       Typename(typeid(VBOArrayType)).c_str(), Typename(typeid(NextType)).c_str() );
                fflush(stdout);
#endif
 
                return VBOField<NextType>::createVBOArray(MB, arrayname, Shader, theCreator);
        }
};
 
 
 
/*
TODO: class     VBOField<LIST<TypedTexCoordArray<Type>, ...>
 
 */
 
} // namespace Wizt
 
#endif  // __VERTEXFIELD_HPP