cens_graphics.h

Go to the documentation of this file.

// Computational Embodied Neuroscience Simulator (CENS) Library
// Copyright (c) 2010 Francesco Mannella
//
// cens_graphics.h
// Copyright (c) 2010 Francesco Mannella
//
// This file is part of CENS library.
//
// CENS library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// CENS 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with CENS library.  If not, see <http://www.gnu.org/licenses/>.

#ifndef CENS_GRAPHICS_H
#define CENS_GRAPHICS_H
#include <vector>

// linear algebra
#include <Eigen/Core>
#include <Eigen/Geometry>
using namespace Eigen;


// OpenGL
#include <GL/glut.h>
#include <GL/freeglut.h>

//ImageMagick
#include <Magick++.h>

#include "cens_graphics_shape.h"
#include "cens_pixelmap.h"
#include "cens_parameter_manager.h"

static const char* graph_params_filename = "graphics_parameters";

namespace cens 
{


    class CENSGraphics 
    {

        public: 

            // CONSTRUCTORS /////////////////////////////////////////////////

            CENSGraphics():m_grParameterManager(graph_params_filename)           
            {

                m_grTextureEnabled=false;
                m_grTextureInitialized=false;
                m_grAxisEnabled=false;
                m_grSimEnabled=false;
                m_grCameraAxisEnabled=false;
                m_grObjectAxesEnabled=false;
                m_grJointAxesEnabled=false;

            };

            ~CENSGraphics();

            // PUBLIC METHODS ///////////////////////////////////////////////

            virtual void initCENSGraphics( int argc, char ** argv );

            virtual void loop(); 

            virtual void stepToStepLoop();

            virtual void step( 
                    int ts   );

            virtual void display();

            virtual bool isIdle();

            virtual void quit();

            virtual void keyboard( unsigned char key, int x, int y );

        protected: 

            // PROTECTED STRUCTS ////////////////////////////////////////////

            struct CENSCamera 
            {

                CENSCamera() {}

                CENSCamera(const CENSCamera& copy) 
                {
                    m_cHandle = copy.m_cHandle;
                    m_cScreenWidth = copy.m_cScreenWidth;
                    m_cScreenHeight = copy.m_cScreenHeight;
                    m_cScreenXGap = copy.m_cScreenXGap;
                    m_cScreenYGap = copy.m_cScreenYGap;
                    m_cScreenTitle = copy.m_cScreenTitle;
                    m_cFoV = copy.m_cFoV;
                    m_cRatio = copy.m_cRatio;
                    m_cNear = copy.m_cNear;
                    m_cFar = copy.m_cFar;
                    m_cAngle = copy.m_cAngle;
                    m_cDistance = copy.m_cDistance;
                    m_cHeight = copy.m_cHeight;
                    m_cOrigin = copy.m_cOrigin;
                    m_cTarget = copy.m_cTarget;
                    m_cUp = copy.m_cUp;
                    m_cMov = copy.m_cMov;
                    m_cGap = copy.m_cGap;
                }

                ~CENSCamera() 
                { 

                }

                void initPixels() {

                    int data_length =
                        m_cScreenWidth * 
                        m_cScreenHeight * 3 ;
                    unsigned char *pixels = 
                        new unsigned char[ data_length ];

                    m_cPixmap=CENSPixelMap();
                    m_cPixmap.setData(pixels,
                            m_cScreenWidth,m_cScreenHeight);

                    delete pixels;

                }

                int m_cHandle;
                int m_cScreenWidth;
                int m_cScreenHeight;
                int m_cScreenXGap;
                int m_cScreenYGap;
                std::string m_cScreenTitle;
                float m_cFoV;       
                float m_cRatio;
                float m_cNear;
                float m_cFar;
                float m_cAngle;
                float m_cDistance;
                float m_cHeight;
                Vector3f m_cOrigin;
                Vector3f m_cTarget;
                Vector3f m_cUp;
                float m_cMov;
                float m_cGap;
                unsigned char *m_cPixels;
                CENSPixelMap m_cPixmap;

            };

            struct CENSLight 
            {

                Vector4f m_lAmbient;
                Vector4f m_lDiffuse;
                Vector4f m_lSpecular;
                Vector4f m_lPosition0;
                Vector4f m_lPosition1;

            };

            // PROTECTED METHODS ////////////////////////////////////////////

            // SETTINGS /////////////////////////////////////////////////////   

            void beginRendering();

            void endRendering();

            void initTextures();

            void initTexture(const GLubyte *source = 0, int width = 0, int height = 0);

        public: 

            // CAMERA ///////////////////////////////////////////////////////

            void initCamera(CENSCamera &camera, CENSLight light);

            void focusCamera(int camera_index);

            void updateCamera(int camera_index);

            const CENSPixelMap &getCameraPixelMap(int camera_index );

            void saveCameraPixelMap(int camera_index, int t, const char * type="jpg" );

            // RENDERING ////////////////////////////////////////////////////

            void drawLine(
                    const Vector3f &v1,
                    const Vector3f &v2,
                    const Vector3f color);

            void drawPlane( 
                    const Vector3f& orig,    
                    const Vector3f& vec0,    
                    const Vector3f& vec1      );

            void drawBox( 
                    const Vector3f& orig,        
                    const Matrix3f& rotMat,      
                    const Vector3f& halfExtent    );

            void drawSphere( 
                    const Vector3f& orig,    
                    const Matrix3f& rot,     
                    float radius              );
                    
            void drawConvex( 
                    const Vector3f& orig,               
                    const Matrix3f& rot ,               
                    const std::vector<Vector3f> &vtx,   
                    const unsigned int *idx,            
                    int nvtxs,                          
                    int nidxs,                          
                    int ntrns                            );  

            void drawAxis(
                    const Vector3f &origin,             
                    const Matrix3f &rotation,           
                    float length                        );

            inline void drawVector( const Vector3f& v  ) 
            { 
                glVertex3d(v[0], v[1], v[2]); 
            }

            void drawTriangle(
                    const Vector3f &v1,     
                    const Vector3f &v2,     
                    const Vector3f &v3,     
                    const Vector3f n         );

            // KEYBOARD /////////////////////////////////////////////////////

            void stepLeft();          
            void stepRight();         
            void stepFront();         
            void stepBack();          
            void zoomIn();            
            void zoomOut();           
            void toggleStop();        
            void toggleTexture();     
            void toggleAxis();        
            void toggleObjectAxes();  
            void toggleJointAxes();   
            void toggleCameraAxis();  
        protected:

            // PROTECTED MEMBERS ////////////////////////////////////////////

            int m_grTimestep;
            int m_grArgc;
            char ** m_grArgv;

            Vector3f m_grEnvColor;
            Vector3f m_grGroundColor;
            Vector3f m_grObjectColor;
            Vector3f m_grBoxColor;
            Vector3f m_grCapsuleColor;
            Vector3f m_grSphereColor;
            Vector3f m_grSoftColor;
            Vector3f m_grCompoundColor;

            bool m_grTextureEnabled;
            bool m_grTextureInitialized;

            bool m_grHide;
            CENSLight m_grLight;

            bool m_grAxisEnabled;
            bool m_grSimEnabled;
            bool m_grCameraAxisEnabled;
            bool m_grObjectAxesEnabled;
            bool m_grJointAxesEnabled;

            CENSCamera m_grViewCamera;
            int m_grEyeCameraNumber;
            std::vector< CENSCamera *> m_grEyeCameras;
            std::vector< CENSCamera *> m_grCameras;
            std::vector< CENSGraphicsShape *> m_grShapes;

            CENSParameterManager m_grParameterManager;
    };



    extern CENSGraphics* cens_graphics; 

}

#endif // CENS_GRAPHICS_H)