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 <ocean/eagle/PhysicalSpace.hpp>

#include <ocean/shrimp/VEnum.hpp>

#include <GL/fieldGL.hpp>
#include <GL/FieldBuffer.hpp>

#include <field/Fragment.hpp>

#include "fisheyeDllApi.h"

namespace Wizt
{

class    fisheye_API  VertexField : public MemCore::ReferenceBase<VertexField>
                                  , public virtual Fish<VObject>
                                  , public virtual Fish<Fiber::Field>
{
public: 
        struct  Error : GLError
        {
                char    fieldname[256];

                Error(const char*what, const string&f)
                : GLError(0, what)
                {
                        strncpy(fieldname, f.c_str(), sizeof(fieldname)-1); 
                        fieldname[sizeof(fieldname)-1] = '\0';
                }
        }; 

        bool ConvertToElements; 

        VertexField(VObject*what,
                    const string&fieldname, bool ConvertToElements=true); 

        ~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)
        : Fish<VObject>(that)
        , Fish<Fiber::Field>(fieldname)
        , VertexField(that, fieldname)
        {
                acceptType<value_type>();
        }

        override RefPtr<BufferArray> createVBOArray(const RefPtr<Fiber::MemBase>&MB,
                                                    const string&arrayname,
                                                    const RefPtr<GLProgram>&Shader,
                                                    const Fiber::MemBase::Creator_t&theCreator
                                                    ) const
        {
//              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)
        : Fish<VObject>(that)
        , Fish<Fiber::Field>(fieldname)
        , VertexField(that, fieldname)
        , TU(TextureUnit)
        {
                acceptType<value_type>();
        }

        override RefPtr<BufferArray> createVBOArray(const RefPtr<Fiber::MemBase>&MB,
                                                    const string&arrayname,
                                                    const RefPtr<GLProgram>&Shader,
                                                    const Fiber::MemBase::Creator_t&theCreator) const
        {
        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)
        : Fish<VObject>(that)
        , Fish<Fiber::Field>(fieldname)
        , VertexField(that, fieldname)
        {
                acceptType<value_type>();
        }

        override RefPtr<BufferArray> createVBOArray(const RefPtr<Fiber::MemBase>&MB,
                                                    const string&arrayname,
                                                    const RefPtr<GLProgram>&Shader,
                                                    const Fiber::MemBase::Creator_t&theCreator) const
        {
                if (!Shader)
                        return NullPtr(); 

        int     Id = Shader->getAttribID( arrayname.c_str() );
                if (Id<0)
                        throw BufferArray::Error("Invalid attribute ID used in associated shader", typeid(Type), MB->getType() ); 

                return GL::FieldBuffer<VBOArrayType>::createParam(Id, MB, true, theCreator ); 
        }
};

} // namespace Wizt

#endif  // __VERTEXFIELD_HPP