fiberGL.hpp

#include <eagle/GL/EagleGL.hpp>
#include <vector/MultiArray.hpp>
#include <field/Cell.hpp>
#include <memcore/Chunk.hpp>
 
#ifndef __FIBER_GL_HPP
#define __FIBER_GL_HPP
 
 
template <> 
        class glType<Fiber::TriangleCell>
{
public:
        enum a { type       = glType<Fiber::TriangleCell::value_type>::type  };
        enum b { utype      = glType<Fiber::TriangleCell::value_type>::type  };
        enum c { components = 3          };
};
 
 
namespace GL
{
using namespace Eagle;
using namespace Fiber;
 
template <class T, int N>
inline void VertexPointer(const ElementIterator<FixedArray<T,N> >&P)
{
        ::glVertexPointer(N, glType<T>::type, 0, P.ptr() );
}
 
template <class T, int N>
inline void ColorPointer(const ElementIterator<FixedArray<T,N> >&P)
{
        ::glColorPointer(N, glType<T>::type, 0, P.ptr() );
}
 
/*
template <class T, int N>
inline void NormalPointer(const ElementIterator<FixedArray<T,N> >&P)
{
        ::glNormalPointer(N, glType<T>::type, 0, P.ptr() );
}
*/
 
inline void VertexPointer(const ElementIterator<point3>&P)
{
        ::glVertexPointer(3, glType<point3::value_type>::type, 0, P.ptr() ); 
}
 
inline void NormalPointer(const ElementIterator<bivector3>&P)
{
        ::glNormalPointer(glType<bivector3::value_type>::type, 0, P.ptr() ); 
}
 
inline void ColorPointer(const ElementIterator<bivector3>&P)
{
        ::glColorPointer(3, glType<bivector3::value_type>::type, 0, P.ptr() ); 
}
 
template <typename T>
inline void IndexPointer(const ElementIterator<T>&P)
{
        ::glIndexPointer(glType<T>::type, 0, P.ptr() ); 
}
 
template <class T>
inline void DrawElements(GLenum mode, const ElementIterator<T>&P)
{
        ::glDrawElements( mode, P.count(), glType<T>::type, P.ptr() );
}
 
template <class T>
inline void DrawPoints(const ElementIterator<T>&P)
{
        ::glDrawElements( GL_POINTS, P.count(), glType<T>::type, P.ptr() );
}
 
template <class T>
inline void DrawLine(const ElementIterator<T>&P)
{
        ::glDrawElements( GL_LINE_STRIP, P.count(), glType<T>::type, P.ptr() );
}
 
 
template <class T>
inline void DrawElements(const ElementIterator<FixedArray<T,2> >&P)
{
        ::glDrawElements( GL_LINES, 2*P.count(), glType<T>::type, P.ptr() );
}
 
template <class T>
inline void DrawElements(const ElementIterator<FixedArray<T,3> >&P)
{
        ::glDrawElements( GL_TRIANGLES, 3*P.count(), glType<T>::type, P.ptr() );
}
 
template <class T>
inline void DrawElements(const ElementIterator<FixedArray<T,4> >&P)
{
        ::glDrawElements( GL_QUADS, 4*P.count(), glType<T>::type, P.ptr() );
}
 
inline void DrawElements(const ElementIterator<TriangleCell>&P)
{
size_t A = TriangleCell::SIZE, B = P.count(),
        C = A*B;
 
        ::glDrawElements( GL_TRIANGLES, C,
                          glType<TriangleCell::value_type>::type, P.ptr() );
}
 
inline void DrawElements(const std::vector<TriangleCell>&P)
{
size_t A = TriangleCell::SIZE, B = P.size(),
        C = A*B;
 
        ::glDrawElements( GL_TRIANGLES, C,
                          glType<TriangleCell::value_type>::type, &*P.begin() );
}
 
inline void DrawElements(const MemCore::Chunk<TriangleCell>&P)
{
        DrawElements(P.std_vector() );
}
 
// glDrawRangeElements
 
template <class Type>
inline bool TexImage(const MultiArray<2, Type>&TextureArray,
                     GLenum format = glType<Type>::format,
                     GLint internalformat = glType<Type>::components,
                     GLint level = 0, GLint border = 0 )
{
        if (TextureArray.multiplicity()>1 && TextureArray.isSeparatedCompound() )
                return false; 
 
//nst Type*Data = 
        if (!TextureArray.ptr())
                return false;
 
        TexImage2D(TextureArray.ptr(),
                   TextureArray.Size()[0],
                   TextureArray.Size()[1],
                   format,
                   internalformat,
                   level, border ); 
 
        return true;
}
 
 
 
template <class Type>
inline bool TexImage(const MultiArray<1, Type>&TextureArray,
                     GLenum format = glType<Type>::format,
                     GLint internalformat = GL_RGB,
                     GLint level = 0, GLint border = 0 )
{
        if (TextureArray.multiplicity()>1 && TextureArray.isSeparatedCompound() )
                return false;
 
const Type*Data = TextureArray.ptr();
        if (!Data)
                return false;
 
        TexImage1D(Data,
                   TextureArray.Size()[0],
                   format,
                   internalformat,
                   level, border ); 
 
        return true;
}
 
 
 
} // GL
 
#endif // __FIBER_GL_HPP