cvd/gles1_helpers.h

/*
    This file is part of the CVD Library.

    Copyright (C) 2005 The Authors

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
#ifndef CVD_GLES1_HELPERS_H
#define CVD_GLES1_HELPERS_H

#include <iostream>
#include <map>
#include <utility>

#include <cvd/image_ref.h>
#include <cvd/image.h>
#include <cvd/byte.h>
#include <cvd/rgb.h>
#include <cvd/byte.h>
#include <cvd/rgb8.h>
#include <cvd/rgba.h>
#include <cvd/config.h>
// #include <OpenGLES/ES1/gl.h>
#include <cvd/internal/gles1_types.h>

#ifdef CVD_HAVE_TOON
#include <TooN/TooN.h>
#include <cvd/se3.h>
#include <cvd/so3.h>
#include <cvd/se2.h>
#include <cvd/so2.h>
#endif

namespace CVD
{

    inline void glTranslate( const ImageRef & v )
    {
        glTranslatef(v.x, v.y, 0);
    }

    template <int N, typename P, typename A> inline void glTranslate( const TooN::Vector<N, P, A> & v)
    {
        glTranslatef(v[0], v[1], v[2]);
    }

    template <typename P, typename A> inline void glTranslate( const TooN::Vector<2, P, A> & v)
    {
        glTranslatef(v[0], v[1], 0);
    }

    template <typename P, typename A> inline void glTranslate( const TooN::Vector<1, P, A> & v)
    {
        glTranslatef(v[0], 0, 0);
    }

    template <int N, class P, class A> inline void glMultMatrix( const TooN::Matrix<N,N,P,A> & m )
    {
        GLfloat glm[16];
        glm[0] = m[0][0]; glm[1] = m[1][0]; glm[2] = m[2][0]; glm[3] = m[3][0];
        glm[4] = m[0][1]; glm[5] = m[1][1]; glm[6] = m[2][1]; glm[7] = m[3][1];
        glm[8] = m[0][2]; glm[9] = m[1][2]; glm[10] = m[2][2]; glm[11] = m[3][2];
        glm[12] = m[0][3]; glm[13] = m[1][3]; glm[14] = m[2][3]; glm[15] = m[3][3];
        glMultMatrixf(glm);
    }

    template <class P, class A> inline void glMultMatrix( const TooN::Matrix<3,3,P,A> & m )
    {
        GLfloat glm[16];
        glm[0] = m[0][0]; glm[1] = m[1][0]; glm[2] = m[2][0]; glm[3] = 0;
        glm[4] = m[0][1]; glm[5] = m[1][1]; glm[6] = m[2][1]; glm[7] = 0;
        glm[8] = m[0][2]; glm[9] = m[1][2]; glm[10] = m[2][2]; glm[11] = 0;
        glm[12] = 0; glm[13] = 0; glm[14] = 0; glm[15] = 1;
        glMultMatrixf(glm);
    }

    template <class P, class A> inline void glMultMatrix( const TooN::Matrix<2,2,P,A> & m )
    {
        GLfloat glm[16];
        glm[0] = m[0][0]; glm[1] = m[1][0]; glm[2] = 0; glm[3] = 0;
        glm[4] = m[0][1]; glm[5] = m[1][1]; glm[6] = 0; glm[7] = 0;
        glm[8] = 0; glm[9] = 0; glm[10] = 1; glm[11] = 0;
        glm[12] = 0; glm[13] = 0; glm[14] = 0; glm[15] = 1;
        glMultMatrixf(glm);
    }

    template <typename P>
    inline void glMultMatrix( const TooN::SO3<P> & so3 )
    {
        glMultMatrix( so3.get_matrix());
    }

    template <typename P>
    inline void glMultMatrix( const TooN::SE3<P> & se3 )
    {
        glTranslate( se3.get_translation());
        glMultMatrix( se3.get_rotation());
    }

    template <typename P>
    inline void glMultMatrix( const TooN::SO2<P> & so2 )
    {
        glMultMatrix( so2.get_matrix());
    }

    template <typename P>
    inline void glMultMatrix( const TooN::SE2<P> & se2 )
    {
        glTranslate( se2.get_translation());
        glMultMatrix( se2.get_rotation());
    }

    template <typename P> inline void glOrtho( const CVD::ImageRef & size, const P nearPlane = -1.0, const P farPlane = 1.0)
    {
        ::glOrthof( -0.375, size.x - 0.375, size.y - 0.375, -0.375, nearPlane, farPlane );
    }

    template <typename P, typename A> inline void glOrtho( const TooN::Vector<6, P, A> & param)
    {
        ::glOrthof( param[0], param[1], param[2], param[3], param[4], param[5]);
    }

    template <typename P, typename A>
    inline void glFrustum( const TooN::Vector<4, P, A> & params, const float width, const float height, const float nearPlane = 0.1, const float farPlane = 100)
    {
        GLfloat left, right, bottom, top;
        left = -nearPlane * params[2] / params[0];
        top = nearPlane * params[3] / params[1];
        right = nearPlane * ( width - params[2] ) / params[0];
        bottom = - nearPlane * ( height - params[3] ) / params[1];
        ::glFrustumf( left, right, bottom, top, nearPlane, farPlane );
    }

    template <class CAMERA> inline void glFrustum( const CAMERA & camera, const float width, const float height, const float nearPlane = 0.1, const float farPlane = 100)
    {
        glFrustum( camera.get_parameters().template slice<0,4>(), width, height, nearPlane, farPlane);
    }

    template <typename P, typename A> inline void glFrustum( const TooN::Vector<6, P, A> & param)
    {
        ::glFrustumf( param[0], param[1], param[2], param[3], param[4], param[5]);
    }
    
    template <typename P, typename A> inline void glColor(const TooN::Vector<3, P, A> & v)
    {
        glColor4f(v[0], v[1], v[2], 1);
    }

    template <typename P, typename A> inline void glColor(const TooN::Vector<4, P, A>& v)
    {
        glColor4f(v[0], v[1], v[2], v[3]);
    }
    
    template <typename P, typename A> inline void glClearColor(const TooN::Vector<4, P, A> & v)
    {
		::glClearColor((GLclampf)v[0], (GLclampf)v[1], (GLclampf)v[2], (GLclampf)v[3]);
    }

    template <typename P, typename A> inline void glClearColor(const TooN::Vector<3, P, A>& v)
    {
		::glClearColor((GLclampf)v[0], (GLclampf)v[1], (GLclampf)v[2], 1);
    }

    template <typename P, typename A> inline void glColor(const TooN::Vector<-1, P, A> & v)
    {
        switch(v.size()){
        case 3: glColor4f(v[0], v[1], v[2], 1);
            break;
        case 4: glColor4f(v[0], v[1], v[2], v[3]);
            break;
        }
    }

    inline void glColor(const CVD::Rgb<byte>& c)
    {
        glColor4ub(c.red, c.green, c.blue, 255);
    }

    inline void glColor(const CVD::Rgb<float>& c)
    {
        glColor4f(c.red, c.green, c.blue, 1);
    }

    inline void glColor3(const CVD::Rgb8& c)
    {
        glColor4ub(c.red, c.green, c.blue, 255);
    }

    inline void glColor4(const CVD::Rgb8& c)
    {
        glColor4ub(c.red, c.green, c.blue, c.dummy);
    }

    inline void glColor(const CVD::Rgba<unsigned char>& c)
    {
        glColor4ub(c.red, c.green, c.blue, c.alpha);
    }

    inline void glColor(const CVD::Rgba<float>& c)
    {
        glColor4f(c.red, c.green, c.blue, c.alpha);
    }

    template<class C> inline void glReadPixels(BasicImage<C>& i, const ImageRef origin=ImageRef(0,0))
    {
		::glReadPixels(origin.x, origin.y, i.size().x, i.size().y, gl::data<C>::format, gl::data<C>::type, i.data());
    }

    template<class C> inline Image<C> glReadPixels(ImageRef size, const ImageRef origin=ImageRef(0,0))
    {
        Image<C> i(size);
		::glReadPixels(origin.x, origin.y, i.size().x, i.size().y, gl::data<C>::format, gl::data<C>::type, i.data());
        return i;
    }

    template<class C> inline void glTexSubImage2D( const SubImage<C> &i, GLint xoffset = 0, GLint yoffset = 0, GLenum target = GL_TEXTURE_2D, GLint level = 0)
    {
        ::glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
		::glTexSubImage2D(target, level, xoffset, yoffset, i.size().x, i.size().y, gl::data<C>::format, gl::data<C>::type, i.data());
    }

    template<class C> inline void glTexImage2D( const SubImage<C> &i, GLint border = 0, GLenum target = GL_TEXTURE_2D, GLint level = 0)
    {
        ::glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
		::glTexImage2D(target, level, gl::data<C>::format, i.size().x, i.size().y, border, gl::data<C>::format, gl::data<C>::type, i.data());
    }

    inline void glPrintErrors(void){
        GLenum code;
        while((code = glGetError()) != GL_NO_ERROR){
            std::cout << "GL:" << code << std::endl;
        }
    }


    void glSetFont( const std::string & fontname );

    const std::string & glGetFont();

    enum TEXT_STYLE {
        FILL = 0,       
        OUTLINE = 1,    
        NICE = 2        
    };

    std::pair<double, double> glDrawText(const std::string & text, enum TEXT_STYLE style = NICE, double spacing = 1.5, double kerning = 0.1);

    std::pair<double, double> glGetExtends(const std::string & text, double spacing = 1.5, double kerning = 0.1);


};

#endif