examples/ObjectAndSensorViewer/ObjectAndSensorViewer.hpp

Go to the documentation of this file.

/*
 *  MAPS-TFSS, Tactile Force Sensor Simulator
 * 
 *  Copyright (C) 2010 Zachary Pezzementi, Lucas Estrade, Erion Plaku,
 *  and Gregory Hager
 *
 *  This program 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.
 *
 *  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef UTILS__ObjectAndSensorViewer_H_
#define UTILS__ObjectAndSensorViewer_H_

#include <cstdlib>
#include <cmath>
#include <cstring>
#include <cctype>
#include <assert.h>
#include <stdio.h>
#include "TactileSensor/SimulatedTactileSensor.hpp"

#include "Graphics/Utils/CompatGL.hpp"

namespace Graphics
{
    
    class ObjectAndSensorViewer;
    typedef ObjectAndSensorViewer* ObjectAndSensorViewerPtr;
    
    class ObjectAndSensorViewer
    {
    public:
        
        static Sensing::SimulatedTactileSensor *sensor1; 
        static Sensing::SimulatedTactileSensor *sensor2; 
        static Sensing::SimulatedTactileSensor *sensor3; 
        
    protected:
        ObjectAndSensorViewer(void)
        {
            for(int i=0; i<2; i++)
            {
                GLUTmouse[i] = 0;
            }
            
            for(int i=0; i<3; i++)
            {
                GLUTbutton[i] = 0;
            }
            
        }
        
    public:
        static ObjectAndSensorViewerPtr& getInstance(void)
        {
            if( !instance )
                instance = new ObjectAndSensorViewer();
            return instance;
        }
        
        // Static functions
        
        static void SGLUTInit(int *argc, char **argv)
        {
            instance = getInstance();
            instance->GLUTInit( argc, argv);
        }
        
        static void SGLUTMainLoop(void)
        {
            instance->GLUTMainLoop();
        }
        
        void GLUTInit(int *argc, char **argv);
        
        void GLUTMainLoop(void);
        
    protected:
        static ObjectAndSensorViewer* instance;
        
        // GLUT variables
        static int GLUTwindow;  
        static int GLUTwindow2; 
        static int GLUTwindow_height;   
        static int GLUTwindow_width;    
        static int GLUTwindow2_height;  
        static int GLUTwindow2_width;   
        static int GLUTmouse[2];    
        static int GLUTbutton[3];   
        static int GLUTmodifiers;   
        
        static int scaling;     
        static int translating; 
        static int rotating;    
        static int zoom;        
        
        static float object_translation[3]; 
        static float object_angle[3];       
        
        //Other variables
        static bool mdl;    
        static bool sns;    
        
        // Static Functions
        
        
        static void SGLUTRedraw(void)
        {
            instance->GLUTRedraw();
        }
        
        static void SGLUTRedraw2(void)
        {
            instance->GLUTRedraw2();
        }
        
        static void SdrawObject(void)
        {
            instance->drawObject();
        }
        
        static void SGLUTStop(void)
        {
            instance->GLUTStop();
        }
        
        static void SGLUTResize(int w, int h)
        {
            instance->GLUTResize(w,h);
        }
        
        static void SGLUTMotion(int x, int y)
        {
            instance->GLUTMotion(x,y);
        }
        
        static void SGLUTMouse(int button, int state, int x, int y)
        {
            instance->GLUTMouse(button,state,x,y);
        }
        
        static void SGLUTSpecial(int key, int x, int y)
        {
            instance->GLUTSpecial(key, x,y);
        }
        
        static void SGLUTKeyboard(unsigned char key, int x, int y)
        {
            instance->GLUTKeyboard(key, x, y);
        }
        
        // GLUT UI code
        virtual void GLUTRedraw(void);
        
        
        virtual void GLUTRedraw2(void);
        
        virtual void drawObject(void);
        
        void GLUTStop(void);
        
        void GLUTResize(int w, int h);
        
        virtual void GLUTMotion(int x, int y);
        
        void GLUTMouse(int button, int state, int x, int y);
        
        void GLUTSpecial(int key, int x, int y);
        
        void GLUTKeyboard(unsigned char key, int x, int y);
        
    private:
        static GLUquadricObj* quad;
        
    };
    
}

#endif